Manette.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .data         00000010  00800100  0000103e  000010d2  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  1 .text         0000103e  00000000  00000000  00000094  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .bss          00000011  00800110  00800110  000010e2  2**0
                  ALLOC
  3 .comment      00000011  00000000  00000000  000010e2  2**0
                  CONTENTS, READONLY
  4 .note.gnu.avr.deviceinfo 00000040  00000000  00000000  000010f4  2**2
                  CONTENTS, READONLY
  5 .debug_aranges 00000270  00000000  00000000  00001134  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_info   000057bc  00000000  00000000  000013a4  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_abbrev 00001b70  00000000  00000000  00006b60  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_line   00003573  00000000  00000000  000086d0  2**0
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_frame  0000075c  00000000  00000000  0000bc44  2**2
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_str    00002478  00000000  00000000  0000c3a0  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_loc    00003125  00000000  00000000  0000e818  2**0
                  CONTENTS, READONLY, DEBUGGING
 12 .debug_ranges 00000388  00000000  00000000  0001193d  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
       0:	b2 c0       	rjmp	.+356    	; 0x166 <__ctors_end>
       2:	00 00       	nop
       4:	cb c0       	rjmp	.+406    	; 0x19c <__bad_interrupt>
       6:	00 00       	nop
       8:	c9 c0       	rjmp	.+402    	; 0x19c <__bad_interrupt>
       a:	00 00       	nop
       c:	c7 c0       	rjmp	.+398    	; 0x19c <__bad_interrupt>
       e:	00 00       	nop
      10:	c5 c0       	rjmp	.+394    	; 0x19c <__bad_interrupt>
      12:	00 00       	nop
      14:	c3 c0       	rjmp	.+390    	; 0x19c <__bad_interrupt>
      16:	00 00       	nop
      18:	c1 c0       	rjmp	.+386    	; 0x19c <__bad_interrupt>
      1a:	00 00       	nop
      1c:	bf c0       	rjmp	.+382    	; 0x19c <__bad_interrupt>
      1e:	00 00       	nop
      20:	bd c0       	rjmp	.+378    	; 0x19c <__bad_interrupt>
      22:	00 00       	nop
      24:	bb c0       	rjmp	.+374    	; 0x19c <__bad_interrupt>
      26:	00 00       	nop
      28:	aa c3       	rjmp	.+1876   	; 0x77e <__vector_10>
      2a:	00 00       	nop
      2c:	b7 c0       	rjmp	.+366    	; 0x19c <__bad_interrupt>
      2e:	00 00       	nop
      30:	b5 c0       	rjmp	.+362    	; 0x19c <__bad_interrupt>
      32:	00 00       	nop
      34:	b3 c0       	rjmp	.+358    	; 0x19c <__bad_interrupt>
      36:	00 00       	nop
      38:	b1 c0       	rjmp	.+354    	; 0x19c <__bad_interrupt>
      3a:	00 00       	nop
      3c:	af c0       	rjmp	.+350    	; 0x19c <__bad_interrupt>
      3e:	00 00       	nop
      40:	ad c0       	rjmp	.+346    	; 0x19c <__bad_interrupt>
      42:	00 00       	nop
      44:	ab c0       	rjmp	.+342    	; 0x19c <__bad_interrupt>
      46:	00 00       	nop
      48:	a9 c0       	rjmp	.+338    	; 0x19c <__bad_interrupt>
      4a:	00 00       	nop
      4c:	a7 c0       	rjmp	.+334    	; 0x19c <__bad_interrupt>
      4e:	00 00       	nop
      50:	a5 c0       	rjmp	.+330    	; 0x19c <__bad_interrupt>
      52:	00 00       	nop
      54:	a3 c0       	rjmp	.+326    	; 0x19c <__bad_interrupt>
      56:	00 00       	nop
      58:	a1 c0       	rjmp	.+322    	; 0x19c <__bad_interrupt>
      5a:	00 00       	nop
      5c:	9f c0       	rjmp	.+318    	; 0x19c <__bad_interrupt>
      5e:	00 00       	nop
      60:	9d c0       	rjmp	.+314    	; 0x19c <__bad_interrupt>
      62:	00 00       	nop
      64:	9b c0       	rjmp	.+310    	; 0x19c <__bad_interrupt>
      66:	00 00       	nop
      68:	99 c0       	rjmp	.+306    	; 0x19c <__bad_interrupt>
      6a:	00 00       	nop
      6c:	97 c0       	rjmp	.+302    	; 0x19c <__bad_interrupt>
      6e:	00 00       	nop
      70:	95 c0       	rjmp	.+298    	; 0x19c <__bad_interrupt>
      72:	00 00       	nop
      74:	93 c0       	rjmp	.+294    	; 0x19c <__bad_interrupt>
      76:	00 00       	nop
      78:	91 c0       	rjmp	.+290    	; 0x19c <__bad_interrupt>
      7a:	00 00       	nop
      7c:	8f c0       	rjmp	.+286    	; 0x19c <__bad_interrupt>
      7e:	00 00       	nop
      80:	8d c0       	rjmp	.+282    	; 0x19c <__bad_interrupt>
      82:	00 00       	nop
      84:	8b c0       	rjmp	.+278    	; 0x19c <__bad_interrupt>
      86:	00 00       	nop
      88:	89 c0       	rjmp	.+274    	; 0x19c <__bad_interrupt>
      8a:	00 00       	nop
      8c:	87 c0       	rjmp	.+270    	; 0x19c <__bad_interrupt>
      8e:	00 00       	nop
      90:	85 c0       	rjmp	.+266    	; 0x19c <__bad_interrupt>
      92:	00 00       	nop
      94:	83 c0       	rjmp	.+262    	; 0x19c <__bad_interrupt>
      96:	00 00       	nop
      98:	81 c0       	rjmp	.+258    	; 0x19c <__bad_interrupt>
      9a:	00 00       	nop
      9c:	7f c0       	rjmp	.+254    	; 0x19c <__bad_interrupt>
      9e:	00 00       	nop
      a0:	7d c0       	rjmp	.+250    	; 0x19c <__bad_interrupt>
      a2:	00 00       	nop
      a4:	7b c0       	rjmp	.+246    	; 0x19c <__bad_interrupt>
      a6:	00 00       	nop
      a8:	79 c0       	rjmp	.+242    	; 0x19c <__bad_interrupt>
      aa:	00 00       	nop

000000ac <ProductString>:
      ac:	1a 03 4c 00 55 00 46 00 41 00 20 00 43 00 48 00     ..L.U.F.A. .C.H.
      bc:	41 00 4e 00 47 00 45 00 44 00 00 00                 A.N.G.E.D...

000000c8 <ManufacturerString>:
      c8:	2a 03 44 00 65 00 61 00 6e 00 20 00 43 00 61 00     *.D.e.a.n. .C.a.
      d8:	6d 00 65 00 52 00 41 00 20 00 43 00 48 00 41 00     m.e.R.A. .C.H.A.
      e8:	4e 00 47 00 45 00 44 00 20 00 00 00                 N.G.E.D. ...

000000f4 <LanguageString>:
      f4:	04 03 09 04                                         ....

000000f8 <ConfigurationDescriptor>:
      f8:	09 02 22 00 01 01 00 c0 32 09 04 00 00 01 03 00     ..".....2.......
     108:	00 00 09 21 11 01 00 01 22 3a 00 07 05 81 03 08     ...!....":......
     118:	00 05                                               ..

0000011a <DeviceDescriptor>:
     11a:	12 01 10 01 00 00 00 08 eb 03 43 20 01 00 01 02     ..........C ....
     12a:	00 01                                               ..

0000012c <JoystickReport>:
     12c:	05 01 09 04 a1 01 09 01 a1 00 09 30 09 31 09 32     ...........0.1.2
     13c:	16 9c ff 26 64 00 36 ff ff 46 01 00 95 03 75 08     ...&d.6..F....u.
     14c:	81 02 c0 05 09 19 01 29 02 15 00 25 01 75 01 95     .......)...%.u..
     15c:	02 81 02 75 06 95 01 81 01 c0                       ...u......

00000166 <__ctors_end>:
     166:	11 24       	eor	r1, r1
     168:	1f be       	out	0x3f, r1	; 63
     16a:	cf ef       	ldi	r28, 0xFF	; 255
     16c:	da e0       	ldi	r29, 0x0A	; 10
     16e:	de bf       	out	0x3e, r29	; 62
     170:	cd bf       	out	0x3d, r28	; 61

00000172 <__do_copy_data>:
     172:	11 e0       	ldi	r17, 0x01	; 1
     174:	a0 e0       	ldi	r26, 0x00	; 0
     176:	b1 e0       	ldi	r27, 0x01	; 1
     178:	ee e3       	ldi	r30, 0x3E	; 62
     17a:	f0 e1       	ldi	r31, 0x10	; 16
     17c:	02 c0       	rjmp	.+4      	; 0x182 <__do_copy_data+0x10>
     17e:	05 90       	lpm	r0, Z+
     180:	0d 92       	st	X+, r0
     182:	a0 31       	cpi	r26, 0x10	; 16
     184:	b1 07       	cpc	r27, r17
     186:	d9 f7       	brne	.-10     	; 0x17e <__do_copy_data+0xc>

00000188 <__do_clear_bss>:
     188:	21 e0       	ldi	r18, 0x01	; 1
     18a:	a0 e1       	ldi	r26, 0x10	; 16
     18c:	b1 e0       	ldi	r27, 0x01	; 1
     18e:	01 c0       	rjmp	.+2      	; 0x192 <.do_clear_bss_start>

00000190 <.do_clear_bss_loop>:
     190:	1d 92       	st	X+, r1

00000192 <.do_clear_bss_start>:
     192:	a1 32       	cpi	r26, 0x21	; 33
     194:	b2 07       	cpc	r27, r18
     196:	e1 f7       	brne	.-8      	; 0x190 <.do_clear_bss_loop>
     198:	1a d0       	rcall	.+52     	; 0x1ce <main>
     19a:	4f c7       	rjmp	.+3742   	; 0x103a <_exit>

0000019c <__bad_interrupt>:
     19c:	31 cf       	rjmp	.-414    	; 0x0 <__vectors>

0000019e <SetupHardware>:
/** Configures the board hardware and chip peripherals for the demo's functionality. */
void SetupHardware(void)
{
#if (ARCH == ARCH_AVR8)
	/* Disable watchdog if enabled by bootloader/fuses */
	MCUSR &= ~(1 << WDRF);
     19e:	84 b7       	in	r24, 0x34	; 52
     1a0:	87 7f       	andi	r24, 0xF7	; 247
     1a2:	84 bf       	out	0x34, r24	; 52
		);
	}
	else
	{
        uint8_t register temp_reg;
		__asm__ __volatile__ (
     1a4:	0f b6       	in	r0, 0x3f	; 63
     1a6:	f8 94       	cli
     1a8:	a8 95       	wdr
     1aa:	80 91 60 00 	lds	r24, 0x0060	; 0x800060 <__TEXT_REGION_LENGTH__+0x7e0060>
     1ae:	88 61       	ori	r24, 0x18	; 24
     1b0:	80 93 60 00 	sts	0x0060, r24	; 0x800060 <__TEXT_REGION_LENGTH__+0x7e0060>
     1b4:	10 92 60 00 	sts	0x0060, r1	; 0x800060 <__TEXT_REGION_LENGTH__+0x7e0060>
     1b8:	0f be       	out	0x3f, r0	; 63
from 1 to 129. Thus, one does not need to use \c clock_div_t type as argument.
*/
void clock_prescale_set(clock_div_t __x)
{
    uint8_t __tmp = _BV(CLKPCE);
    __asm__ __volatile__ (
     1ba:	90 e0       	ldi	r25, 0x00	; 0
     1bc:	80 e8       	ldi	r24, 0x80	; 128
     1be:	0f b6       	in	r0, 0x3f	; 63
     1c0:	f8 94       	cli
     1c2:	80 93 61 00 	sts	0x0061, r24	; 0x800061 <__TEXT_REGION_LENGTH__+0x7e0061>
     1c6:	90 93 61 00 	sts	0x0061, r25	; 0x800061 <__TEXT_REGION_LENGTH__+0x7e0061>
     1ca:	0f be       	out	0x3f, r0	; 63

	/* Hardware Initialization */
	Joystick_Init();
	LEDs_Init();
	Buttons_Init();
	USB_Init();
     1cc:	bb c2       	rjmp	.+1398   	; 0x744 <USB_Init>

000001ce <main>:
/** Main program entry point. This routine contains the overall program flow, including initial
 *  setup of all components and the main program loop.
 */
int main(void)
{
	SetupHardware();
     1ce:	e7 df       	rcall	.-50     	; 0x19e <SetupHardware>
			static inline void GlobalInterruptEnable(void)
			{
				GCC_MEMORY_BARRIER();

				#if (ARCH == ARCH_AVR8)
				sei();
     1d0:	78 94       	sei
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
	GlobalInterruptEnable();

	for (;;)
	{
		HID_Device_USBTask(&Joystick_HID_Interface);
     1d2:	80 e0       	ldi	r24, 0x00	; 0
     1d4:	91 e0       	ldi	r25, 0x01	; 1
		USB_USBTask();
     1d6:	5b d6       	rcall	.+3254   	; 0xe8e <HID_Device_USBTask>
     1d8:	fa d4       	rcall	.+2548   	; 0xbce <USB_USBTask>
     1da:	fb cf       	rjmp	.-10     	; 0x1d2 <main+0x4>

000001dc <EVENT_USB_Device_Connect>:
     1dc:	08 95       	ret

000001de <EVENT_USB_Device_Disconnect>:
	LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
}

/** Event handler for the library USB Disconnection event. */
void EVENT_USB_Device_Disconnect(void)
{
     1de:	08 95       	ret

000001e0 <EVENT_USB_Device_ConfigurationChanged>:
/** Event handler for the library USB Configuration Changed event. */
void EVENT_USB_Device_ConfigurationChanged(void)
{
	bool ConfigSuccess = true;

	ConfigSuccess &= HID_Device_ConfigureEndpoints(&Joystick_HID_Interface);
     1e0:	80 e0       	ldi	r24, 0x00	; 0
     1e2:	91 e0       	ldi	r25, 0x01	; 1
     1e4:	41 d6       	rcall	.+3202   	; 0xe68 <HID_Device_ConfigureEndpoints>
						break;
					case USB_INT_EORSTI:
						UDIEN  |= (1 << EORSTE);
						break;
					case USB_INT_SOFI:
						UDIEN  |= (1 << SOFE);
     1e6:	e2 ee       	ldi	r30, 0xE2	; 226
     1e8:	f0 e0       	ldi	r31, 0x00	; 0
     1ea:	80 81       	ld	r24, Z
     1ec:	84 60       	ori	r24, 0x04	; 4
     1ee:	80 83       	st	Z, r24
     1f0:	08 95       	ret

000001f2 <EVENT_USB_Device_ControlRequest>:
}

/** Event handler for the library USB Control Request reception event. */
void EVENT_USB_Device_ControlRequest(void)
{
	HID_Device_ProcessControlRequest(&Joystick_HID_Interface);
     1f2:	80 e0       	ldi	r24, 0x00	; 0
     1f4:	91 e0       	ldi	r25, 0x01	; 1
     1f6:	05 c5       	rjmp	.+2570   	; 0xc02 <HID_Device_ProcessControlRequest>

000001f8 <EVENT_USB_Device_StartOfFrame>:
			 *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.
			 */
			static inline void HID_Device_MillisecondElapsed(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo) ATTR_ALWAYS_INLINE ATTR_NON_NULL_PTR_ARG(1);
			static inline void HID_Device_MillisecondElapsed(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
			{
				if (HIDInterfaceInfo->State.IdleMSRemaining)
     1f8:	80 91 0e 01 	lds	r24, 0x010E	; 0x80010e <Joystick_HID_Interface+0xe>
     1fc:	90 91 0f 01 	lds	r25, 0x010F	; 0x80010f <Joystick_HID_Interface+0xf>
     200:	00 97       	sbiw	r24, 0x00	; 0
     202:	29 f0       	breq	.+10     	; 0x20e <EVENT_USB_Device_StartOfFrame+0x16>
				  HIDInterfaceInfo->State.IdleMSRemaining--;
     204:	01 97       	sbiw	r24, 0x01	; 1
     206:	90 93 0f 01 	sts	0x010F, r25	; 0x80010f <Joystick_HID_Interface+0xf>
     20a:	80 93 0e 01 	sts	0x010E, r24	; 0x80010e <Joystick_HID_Interface+0xe>
     20e:	08 95       	ret

00000210 <CALLBACK_HID_Device_CreateHIDReport>:
bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo,
                                         uint8_t* const ReportID,
                                         const uint8_t ReportType,
                                         void* ReportData,
                                         uint16_t* const ReportSize)
{
     210:	0f 93       	push	r16
     212:	1f 93       	push	r17
	  JoystickReport->Button |= (1 << 1);

	if (ButtonStatus_LCL & BUTTONS_BUTTON1)
	  JoystickReport->Button |= (1 << 0);

	*ReportSize = sizeof(USB_JoystickReport_Data_t);
     214:	84 e0       	ldi	r24, 0x04	; 4
     216:	90 e0       	ldi	r25, 0x00	; 0
     218:	f8 01       	movw	r30, r16
     21a:	91 83       	std	Z+1, r25	; 0x01
     21c:	80 83       	st	Z, r24
	return false;
}
     21e:	80 e0       	ldi	r24, 0x00	; 0
     220:	1f 91       	pop	r17
     222:	0f 91       	pop	r16
     224:	08 95       	ret

00000226 <CALLBACK_HID_Device_ProcessHIDReport>:
void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo,
                                          const uint8_t ReportID,
                                          const uint8_t ReportType,
                                          const void* ReportData,
                                          const uint16_t ReportSize)
{
     226:	08 95       	ret

00000228 <CALLBACK_USB_GetDescriptor>:
	const uint8_t  DescriptorNumber = (wValue & 0xFF);

	const void* Address = NULL;
	uint16_t    Size    = NO_DESCRIPTOR;

	switch (DescriptorType)
     228:	29 2f       	mov	r18, r25
     22a:	33 27       	eor	r19, r19
     22c:	23 30       	cpi	r18, 0x03	; 3
     22e:	31 05       	cpc	r19, r1
     230:	e1 f0       	breq	.+56     	; 0x26a <CALLBACK_USB_GetDescriptor+0x42>
     232:	58 f4       	brcc	.+22     	; 0x24a <CALLBACK_USB_GetDescriptor+0x22>
     234:	21 30       	cpi	r18, 0x01	; 1
     236:	31 05       	cpc	r19, r1
     238:	99 f0       	breq	.+38     	; 0x260 <CALLBACK_USB_GetDescriptor+0x38>
     23a:	22 30       	cpi	r18, 0x02	; 2
     23c:	31 05       	cpc	r19, r1
     23e:	69 f5       	brne	.+90     	; 0x29a <CALLBACK_USB_GetDescriptor+0x72>
			Address = &DeviceDescriptor;
			Size    = sizeof(USB_Descriptor_Device_t);
			break;
		case DTYPE_Configuration:
			Address = &ConfigurationDescriptor;
			Size    = sizeof(USB_Descriptor_Configuration_t);
     240:	82 e2       	ldi	r24, 0x22	; 34
     242:	90 e0       	ldi	r25, 0x00	; 0
		case DTYPE_Device:
			Address = &DeviceDescriptor;
			Size    = sizeof(USB_Descriptor_Device_t);
			break;
		case DTYPE_Configuration:
			Address = &ConfigurationDescriptor;
     244:	28 ef       	ldi	r18, 0xF8	; 248
     246:	30 e0       	ldi	r19, 0x00	; 0
			Size    = sizeof(USB_Descriptor_Configuration_t);
			break;
     248:	2c c0       	rjmp	.+88     	; 0x2a2 <CALLBACK_USB_GetDescriptor+0x7a>
	const uint8_t  DescriptorNumber = (wValue & 0xFF);

	const void* Address = NULL;
	uint16_t    Size    = NO_DESCRIPTOR;

	switch (DescriptorType)
     24a:	21 32       	cpi	r18, 0x21	; 33
     24c:	31 05       	cpc	r19, r1
     24e:	01 f1       	breq	.+64     	; 0x290 <CALLBACK_USB_GetDescriptor+0x68>
     250:	22 32       	cpi	r18, 0x22	; 34
     252:	31 05       	cpc	r19, r1
     254:	11 f5       	brne	.+68     	; 0x29a <CALLBACK_USB_GetDescriptor+0x72>
			Address = &ConfigurationDescriptor.HID_JoystickHID;
			Size    = sizeof(USB_HID_Descriptor_HID_t);
			break;
		case HID_DTYPE_Report:
			Address = &JoystickReport;
			Size    = sizeof(JoystickReport);
     256:	8a e3       	ldi	r24, 0x3A	; 58
     258:	90 e0       	ldi	r25, 0x00	; 0
		case HID_DTYPE_HID:
			Address = &ConfigurationDescriptor.HID_JoystickHID;
			Size    = sizeof(USB_HID_Descriptor_HID_t);
			break;
		case HID_DTYPE_Report:
			Address = &JoystickReport;
     25a:	2c e2       	ldi	r18, 0x2C	; 44
     25c:	31 e0       	ldi	r19, 0x01	; 1
			Size    = sizeof(JoystickReport);
			break;
     25e:	21 c0       	rjmp	.+66     	; 0x2a2 <CALLBACK_USB_GetDescriptor+0x7a>

	switch (DescriptorType)
	{
		case DTYPE_Device:
			Address = &DeviceDescriptor;
			Size    = sizeof(USB_Descriptor_Device_t);
     260:	82 e1       	ldi	r24, 0x12	; 18
     262:	90 e0       	ldi	r25, 0x00	; 0
	uint16_t    Size    = NO_DESCRIPTOR;

	switch (DescriptorType)
	{
		case DTYPE_Device:
			Address = &DeviceDescriptor;
     264:	2a e1       	ldi	r18, 0x1A	; 26
     266:	31 e0       	ldi	r19, 0x01	; 1
     268:	1c c0       	rjmp	.+56     	; 0x2a2 <CALLBACK_USB_GetDescriptor+0x7a>
		case DTYPE_Configuration:
			Address = &ConfigurationDescriptor;
			Size    = sizeof(USB_Descriptor_Configuration_t);
			break;
		case DTYPE_String:
			switch (DescriptorNumber)
     26a:	99 27       	eor	r25, r25
     26c:	81 30       	cpi	r24, 0x01	; 1
     26e:	91 05       	cpc	r25, r1
     270:	49 f0       	breq	.+18     	; 0x284 <CALLBACK_USB_GetDescriptor+0x5c>
     272:	28 f0       	brcs	.+10     	; 0x27e <CALLBACK_USB_GetDescriptor+0x56>
     274:	02 97       	sbiw	r24, 0x02	; 2
     276:	89 f4       	brne	.+34     	; 0x29a <CALLBACK_USB_GetDescriptor+0x72>
					Address = &ManufacturerString;
					Size    = pgm_read_byte(&ManufacturerString.Header.Size);
					break;
				case STRING_ID_Product:
					Address = &ProductString;
					Size    = pgm_read_byte(&ProductString.Header.Size);
     278:	ec ea       	ldi	r30, 0xAC	; 172
     27a:	f0 e0       	ldi	r31, 0x00	; 0
     27c:	05 c0       	rjmp	.+10     	; 0x288 <CALLBACK_USB_GetDescriptor+0x60>
		case DTYPE_String:
			switch (DescriptorNumber)
			{
				case STRING_ID_Language:
					Address = &LanguageString;
					Size    = pgm_read_byte(&LanguageString.Header.Size);
     27e:	e4 ef       	ldi	r30, 0xF4	; 244
     280:	f0 e0       	ldi	r31, 0x00	; 0
     282:	02 c0       	rjmp	.+4      	; 0x288 <CALLBACK_USB_GetDescriptor+0x60>
					break;
				case STRING_ID_Manufacturer:
					Address = &ManufacturerString;
					Size    = pgm_read_byte(&ManufacturerString.Header.Size);
     284:	e8 ec       	ldi	r30, 0xC8	; 200
     286:	f0 e0       	ldi	r31, 0x00	; 0
					break;
				case STRING_ID_Product:
					Address = &ProductString;
					Size    = pgm_read_byte(&ProductString.Header.Size);
     288:	84 91       	lpm	r24, Z
     28a:	90 e0       	ldi	r25, 0x00	; 0
				case STRING_ID_Manufacturer:
					Address = &ManufacturerString;
					Size    = pgm_read_byte(&ManufacturerString.Header.Size);
					break;
				case STRING_ID_Product:
					Address = &ProductString;
     28c:	9f 01       	movw	r18, r30
					Size    = pgm_read_byte(&ProductString.Header.Size);
					break;
     28e:	09 c0       	rjmp	.+18     	; 0x2a2 <CALLBACK_USB_GetDescriptor+0x7a>
			}

			break;
		case HID_DTYPE_HID:
			Address = &ConfigurationDescriptor.HID_JoystickHID;
			Size    = sizeof(USB_HID_Descriptor_HID_t);
     290:	89 e0       	ldi	r24, 0x09	; 9
     292:	90 e0       	ldi	r25, 0x00	; 0
					break;
			}

			break;
		case HID_DTYPE_HID:
			Address = &ConfigurationDescriptor.HID_JoystickHID;
     294:	2a e0       	ldi	r18, 0x0A	; 10
     296:	31 e0       	ldi	r19, 0x01	; 1
			Size    = sizeof(USB_HID_Descriptor_HID_t);
			break;
     298:	04 c0       	rjmp	.+8      	; 0x2a2 <CALLBACK_USB_GetDescriptor+0x7a>
{
	const uint8_t  DescriptorType   = (wValue >> 8);
	const uint8_t  DescriptorNumber = (wValue & 0xFF);

	const void* Address = NULL;
	uint16_t    Size    = NO_DESCRIPTOR;
     29a:	80 e0       	ldi	r24, 0x00	; 0
     29c:	90 e0       	ldi	r25, 0x00	; 0
                                    const void** const DescriptorAddress)
{
	const uint8_t  DescriptorType   = (wValue >> 8);
	const uint8_t  DescriptorNumber = (wValue & 0xFF);

	const void* Address = NULL;
     29e:	20 e0       	ldi	r18, 0x00	; 0
     2a0:	30 e0       	ldi	r19, 0x00	; 0
			Address = &JoystickReport;
			Size    = sizeof(JoystickReport);
			break;
	}

	*DescriptorAddress = Address;
     2a2:	fa 01       	movw	r30, r20
     2a4:	31 83       	std	Z+1, r19	; 0x01
     2a6:	20 83       	st	Z, r18
	return Size;
}
     2a8:	08 95       	ret

000002aa <Endpoint_Write_Stream_LE>:
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
		  return ENDPOINT_RWCSTREAM_BusSuspended;
	}

	return ENDPOINT_RWCSTREAM_NoError;
}
     2aa:	cf 92       	push	r12
     2ac:	df 92       	push	r13
     2ae:	ef 92       	push	r14
     2b0:	ff 92       	push	r15
     2b2:	0f 93       	push	r16
     2b4:	1f 93       	push	r17
     2b6:	cf 93       	push	r28
     2b8:	df 93       	push	r29
     2ba:	ec 01       	movw	r28, r24
     2bc:	8b 01       	movw	r16, r22
     2be:	7a 01       	movw	r14, r20
     2c0:	ce d1       	rcall	.+924    	; 0x65e <Endpoint_WaitUntilReady>
     2c2:	81 11       	cpse	r24, r1
     2c4:	33 c0       	rjmp	.+102    	; 0x32c <Endpoint_Write_Stream_LE+0x82>
     2c6:	e1 14       	cp	r14, r1
     2c8:	f1 04       	cpc	r15, r1
     2ca:	39 f0       	breq	.+14     	; 0x2da <Endpoint_Write_Stream_LE+0x30>
     2cc:	f7 01       	movw	r30, r14
     2ce:	80 81       	ld	r24, Z
     2d0:	91 81       	ldd	r25, Z+1	; 0x01
     2d2:	08 1b       	sub	r16, r24
     2d4:	19 0b       	sbc	r17, r25
     2d6:	c8 0f       	add	r28, r24
     2d8:	d9 1f       	adc	r29, r25
     2da:	c1 2c       	mov	r12, r1
     2dc:	d1 2c       	mov	r13, r1
     2de:	01 15       	cp	r16, r1
     2e0:	11 05       	cpc	r17, r1
     2e2:	19 f1       	breq	.+70     	; 0x32a <Endpoint_Write_Stream_LE+0x80>
     2e4:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     2e8:	85 fd       	sbrc	r24, 5
     2ea:	16 c0       	rjmp	.+44     	; 0x318 <Endpoint_Write_Stream_LE+0x6e>
     2ec:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     2f0:	8e 77       	andi	r24, 0x7E	; 126
     2f2:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     2f6:	6b d4       	rcall	.+2262   	; 0xbce <USB_USBTask>
     2f8:	e1 14       	cp	r14, r1
     2fa:	f1 04       	cpc	r15, r1
     2fc:	49 f0       	breq	.+18     	; 0x310 <Endpoint_Write_Stream_LE+0x66>
     2fe:	f7 01       	movw	r30, r14
     300:	80 81       	ld	r24, Z
     302:	91 81       	ldd	r25, Z+1	; 0x01
     304:	c8 0e       	add	r12, r24
     306:	d9 1e       	adc	r13, r25
     308:	d1 82       	std	Z+1, r13	; 0x01
     30a:	c0 82       	st	Z, r12
     30c:	85 e0       	ldi	r24, 0x05	; 5
     30e:	0e c0       	rjmp	.+28     	; 0x32c <Endpoint_Write_Stream_LE+0x82>
     310:	a6 d1       	rcall	.+844    	; 0x65e <Endpoint_WaitUntilReady>
     312:	88 23       	and	r24, r24
     314:	21 f3       	breq	.-56     	; 0x2de <Endpoint_Write_Stream_LE+0x34>
     316:	0a c0       	rjmp	.+20     	; 0x32c <Endpoint_Write_Stream_LE+0x82>
     318:	89 91       	ld	r24, Y+
     31a:	80 93 f1 00 	sts	0x00F1, r24	; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1>
     31e:	01 50       	subi	r16, 0x01	; 1
     320:	11 09       	sbc	r17, r1
     322:	ff ef       	ldi	r31, 0xFF	; 255
     324:	cf 1a       	sub	r12, r31
     326:	df 0a       	sbc	r13, r31
     328:	da cf       	rjmp	.-76     	; 0x2de <Endpoint_Write_Stream_LE+0x34>
     32a:	80 e0       	ldi	r24, 0x00	; 0
     32c:	df 91       	pop	r29
     32e:	cf 91       	pop	r28
     330:	1f 91       	pop	r17
     332:	0f 91       	pop	r16
     334:	ff 90       	pop	r15
     336:	ef 90       	pop	r14
     338:	df 90       	pop	r13
     33a:	cf 90       	pop	r12
     33c:	08 95       	ret

0000033e <Endpoint_Write_Control_Stream_LE>:
     33e:	20 91 1f 01 	lds	r18, 0x011F	; 0x80011f <USB_ControlRequest+0x6>
     342:	30 91 20 01 	lds	r19, 0x0120	; 0x800120 <USB_ControlRequest+0x7>
     346:	26 17       	cp	r18, r22
     348:	37 07       	cpc	r19, r23
     34a:	48 f0       	brcs	.+18     	; 0x35e <Endpoint_Write_Control_Stream_LE+0x20>
     34c:	61 15       	cp	r22, r1
     34e:	71 05       	cpc	r23, r1
     350:	39 f4       	brne	.+14     	; 0x360 <Endpoint_Write_Control_Stream_LE+0x22>
     352:	20 91 e8 00 	lds	r18, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     356:	2e 77       	andi	r18, 0x7E	; 126
     358:	20 93 e8 00 	sts	0x00E8, r18	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     35c:	01 c0       	rjmp	.+2      	; 0x360 <Endpoint_Write_Control_Stream_LE+0x22>
     35e:	b9 01       	movw	r22, r18
     360:	fc 01       	movw	r30, r24
     362:	20 e0       	ldi	r18, 0x00	; 0
     364:	61 15       	cp	r22, r1
     366:	71 05       	cpc	r23, r1
     368:	79 f1       	breq	.+94     	; 0x3c8 <Endpoint_Write_Control_Stream_LE+0x8a>
     36a:	80 91 18 01 	lds	r24, 0x0118	; 0x800118 <USB_DeviceState>
     36e:	88 23       	and	r24, r24
     370:	f1 f1       	breq	.+124    	; 0x3ee <Endpoint_Write_Control_Stream_LE+0xb0>
     372:	85 30       	cpi	r24, 0x05	; 5
     374:	f1 f1       	breq	.+124    	; 0x3f2 <Endpoint_Write_Control_Stream_LE+0xb4>
     376:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     37a:	83 fd       	sbrc	r24, 3
     37c:	3c c0       	rjmp	.+120    	; 0x3f6 <Endpoint_Write_Control_Stream_LE+0xb8>
     37e:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     382:	82 fd       	sbrc	r24, 2
     384:	2e c0       	rjmp	.+92     	; 0x3e2 <Endpoint_Write_Control_Stream_LE+0xa4>
     386:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     38a:	80 ff       	sbrs	r24, 0
     38c:	eb cf       	rjmp	.-42     	; 0x364 <Endpoint_Write_Control_Stream_LE+0x26>
     38e:	20 91 f3 00 	lds	r18, 0x00F3	; 0x8000f3 <__TEXT_REGION_LENGTH__+0x7e00f3>
     392:	80 91 f2 00 	lds	r24, 0x00F2	; 0x8000f2 <__TEXT_REGION_LENGTH__+0x7e00f2>
     396:	90 e0       	ldi	r25, 0x00	; 0
     398:	92 2b       	or	r25, r18
     39a:	61 15       	cp	r22, r1
     39c:	71 05       	cpc	r23, r1
     39e:	51 f0       	breq	.+20     	; 0x3b4 <Endpoint_Write_Control_Stream_LE+0x76>
     3a0:	88 30       	cpi	r24, 0x08	; 8
     3a2:	91 05       	cpc	r25, r1
     3a4:	38 f4       	brcc	.+14     	; 0x3b4 <Endpoint_Write_Control_Stream_LE+0x76>
     3a6:	21 91       	ld	r18, Z+
     3a8:	20 93 f1 00 	sts	0x00F1, r18	; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1>
     3ac:	61 50       	subi	r22, 0x01	; 1
     3ae:	71 09       	sbc	r23, r1
     3b0:	01 96       	adiw	r24, 0x01	; 1
     3b2:	f3 cf       	rjmp	.-26     	; 0x39a <Endpoint_Write_Control_Stream_LE+0x5c>
     3b4:	21 e0       	ldi	r18, 0x01	; 1
     3b6:	08 97       	sbiw	r24, 0x08	; 8
     3b8:	09 f0       	breq	.+2      	; 0x3bc <Endpoint_Write_Control_Stream_LE+0x7e>
     3ba:	20 e0       	ldi	r18, 0x00	; 0
     3bc:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     3c0:	8e 77       	andi	r24, 0x7E	; 126
     3c2:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     3c6:	ce cf       	rjmp	.-100    	; 0x364 <Endpoint_Write_Control_Stream_LE+0x26>
     3c8:	21 11       	cpse	r18, r1
     3ca:	cf cf       	rjmp	.-98     	; 0x36a <Endpoint_Write_Control_Stream_LE+0x2c>
     3cc:	0a c0       	rjmp	.+20     	; 0x3e2 <Endpoint_Write_Control_Stream_LE+0xa4>
     3ce:	80 91 18 01 	lds	r24, 0x0118	; 0x800118 <USB_DeviceState>
     3d2:	88 23       	and	r24, r24
     3d4:	61 f0       	breq	.+24     	; 0x3ee <Endpoint_Write_Control_Stream_LE+0xb0>
     3d6:	85 30       	cpi	r24, 0x05	; 5
     3d8:	61 f0       	breq	.+24     	; 0x3f2 <Endpoint_Write_Control_Stream_LE+0xb4>
     3da:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     3de:	83 fd       	sbrc	r24, 3
     3e0:	0a c0       	rjmp	.+20     	; 0x3f6 <Endpoint_Write_Control_Stream_LE+0xb8>
     3e2:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     3e6:	82 ff       	sbrs	r24, 2
     3e8:	f2 cf       	rjmp	.-28     	; 0x3ce <Endpoint_Write_Control_Stream_LE+0x90>
     3ea:	80 e0       	ldi	r24, 0x00	; 0
     3ec:	08 95       	ret
     3ee:	82 e0       	ldi	r24, 0x02	; 2
     3f0:	08 95       	ret
     3f2:	83 e0       	ldi	r24, 0x03	; 3
     3f4:	08 95       	ret
     3f6:	81 e0       	ldi	r24, 0x01	; 1
     3f8:	08 95       	ret

000003fa <Endpoint_Read_Control_Stream_LE>:
     3fa:	61 15       	cp	r22, r1
     3fc:	71 05       	cpc	r23, r1
     3fe:	29 f4       	brne	.+10     	; 0x40a <__LOCK_REGION_LENGTH__+0xa>
     400:	20 91 e8 00 	lds	r18, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     404:	2b 77       	andi	r18, 0x7B	; 123
     406:	20 93 e8 00 	sts	0x00E8, r18	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     40a:	fc 01       	movw	r30, r24
     40c:	61 15       	cp	r22, r1
     40e:	71 05       	cpc	r23, r1
     410:	41 f1       	breq	.+80     	; 0x462 <__LOCK_REGION_LENGTH__+0x62>
     412:	80 91 18 01 	lds	r24, 0x0118	; 0x800118 <USB_DeviceState>
     416:	88 23       	and	r24, r24
     418:	61 f1       	breq	.+88     	; 0x472 <__LOCK_REGION_LENGTH__+0x72>
     41a:	85 30       	cpi	r24, 0x05	; 5
     41c:	61 f1       	breq	.+88     	; 0x476 <__LOCK_REGION_LENGTH__+0x76>
     41e:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     422:	83 fd       	sbrc	r24, 3
     424:	24 c0       	rjmp	.+72     	; 0x46e <__LOCK_REGION_LENGTH__+0x6e>
     426:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     42a:	82 ff       	sbrs	r24, 2
     42c:	ef cf       	rjmp	.-34     	; 0x40c <__LOCK_REGION_LENGTH__+0xc>
     42e:	20 91 f3 00 	lds	r18, 0x00F3	; 0x8000f3 <__TEXT_REGION_LENGTH__+0x7e00f3>
     432:	80 91 f2 00 	lds	r24, 0x00F2	; 0x8000f2 <__TEXT_REGION_LENGTH__+0x7e00f2>
     436:	90 e0       	ldi	r25, 0x00	; 0
     438:	92 2b       	or	r25, r18
     43a:	89 2b       	or	r24, r25
     43c:	31 f0       	breq	.+12     	; 0x44a <__LOCK_REGION_LENGTH__+0x4a>
     43e:	80 91 f1 00 	lds	r24, 0x00F1	; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1>
     442:	81 93       	st	Z+, r24
     444:	61 50       	subi	r22, 0x01	; 1
     446:	71 09       	sbc	r23, r1
     448:	91 f7       	brne	.-28     	; 0x42e <__LOCK_REGION_LENGTH__+0x2e>
     44a:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     44e:	8b 77       	andi	r24, 0x7B	; 123
     450:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     454:	db cf       	rjmp	.-74     	; 0x40c <__LOCK_REGION_LENGTH__+0xc>
     456:	80 91 18 01 	lds	r24, 0x0118	; 0x800118 <USB_DeviceState>
     45a:	88 23       	and	r24, r24
     45c:	51 f0       	breq	.+20     	; 0x472 <__LOCK_REGION_LENGTH__+0x72>
     45e:	85 30       	cpi	r24, 0x05	; 5
     460:	51 f0       	breq	.+20     	; 0x476 <__LOCK_REGION_LENGTH__+0x76>
     462:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     466:	80 ff       	sbrs	r24, 0
     468:	f6 cf       	rjmp	.-20     	; 0x456 <__LOCK_REGION_LENGTH__+0x56>
     46a:	80 e0       	ldi	r24, 0x00	; 0
     46c:	08 95       	ret
     46e:	81 e0       	ldi	r24, 0x01	; 1
     470:	08 95       	ret
     472:	82 e0       	ldi	r24, 0x02	; 2
     474:	08 95       	ret
     476:	83 e0       	ldi	r24, 0x03	; 3
     478:	08 95       	ret

0000047a <Endpoint_Write_Control_PStream_LE>:
                            uint16_t Length)
{
	uint8_t* DataStream     = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length));
	bool     LastPacketFull = false;

	if (Length > USB_ControlRequest.wLength)
     47a:	20 91 1f 01 	lds	r18, 0x011F	; 0x80011f <USB_ControlRequest+0x6>
     47e:	30 91 20 01 	lds	r19, 0x0120	; 0x800120 <USB_ControlRequest+0x7>
     482:	26 17       	cp	r18, r22
     484:	37 07       	cpc	r19, r23
     486:	48 f0       	brcs	.+18     	; 0x49a <Endpoint_Write_Control_PStream_LE+0x20>
	  Length = USB_ControlRequest.wLength;
	else if (!(Length))
     488:	61 15       	cp	r22, r1
     48a:	71 05       	cpc	r23, r1
     48c:	39 f4       	brne	.+14     	; 0x49c <Endpoint_Write_Control_PStream_LE+0x22>
			 */
			static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearIN(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
     48e:	20 91 e8 00 	lds	r18, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     492:	2e 77       	andi	r18, 0x7E	; 126
     494:	20 93 e8 00 	sts	0x00E8, r18	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     498:	01 c0       	rjmp	.+2      	; 0x49c <Endpoint_Write_Control_PStream_LE+0x22>
     49a:	b9 01       	movw	r22, r18
     49c:	fc 01       	movw	r30, r24
     49e:	20 e0       	ldi	r18, 0x00	; 0
	  Endpoint_ClearIN();

	while (Length || LastPacketFull)
     4a0:	61 15       	cp	r22, r1
     4a2:	71 05       	cpc	r23, r1
     4a4:	91 f1       	breq	.+100    	; 0x50a <Endpoint_Write_Control_PStream_LE+0x90>
	{
		uint8_t USB_DeviceState_LCL = USB_DeviceState;
     4a6:	80 91 18 01 	lds	r24, 0x0118	; 0x800118 <USB_DeviceState>

		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
     4aa:	88 23       	and	r24, r24
     4ac:	09 f4       	brne	.+2      	; 0x4b0 <Endpoint_Write_Control_PStream_LE+0x36>
     4ae:	40 c0       	rjmp	.+128    	; 0x530 <Endpoint_Write_Control_PStream_LE+0xb6>
		  return ENDPOINT_RWCSTREAM_DeviceDisconnected;
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
     4b0:	85 30       	cpi	r24, 0x05	; 5
     4b2:	09 f4       	brne	.+2      	; 0x4b6 <Endpoint_Write_Control_PStream_LE+0x3c>
     4b4:	3f c0       	rjmp	.+126    	; 0x534 <Endpoint_Write_Control_PStream_LE+0xba>
			 *  \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsSETUPReceived(void)
			{
				return ((UEINTX & (1 << RXSTPI)) ? true : false);
     4b6:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
		  return ENDPOINT_RWCSTREAM_BusSuspended;
		else if (Endpoint_IsSETUPReceived())
     4ba:	83 fd       	sbrc	r24, 3
     4bc:	3d c0       	rjmp	.+122    	; 0x538 <Endpoint_Write_Control_PStream_LE+0xbe>
			 *  \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsOUTReceived(void)
			{
				return ((UEINTX & (1 << RXOUTI)) ? true : false);
     4be:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
		  return ENDPOINT_RWCSTREAM_HostAborted;
		else if (Endpoint_IsOUTReceived())
     4c2:	82 fd       	sbrc	r24, 2
     4c4:	2f c0       	rjmp	.+94     	; 0x524 <Endpoint_Write_Control_PStream_LE+0xaa>
			 *  \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsINReady(void)
			{
				return ((UEINTX & (1 << TXINI)) ? true : false);
     4c6:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
		  break;

		if (Endpoint_IsINReady())
     4ca:	80 ff       	sbrs	r24, 0
     4cc:	e9 cf       	rjmp	.-46     	; 0x4a0 <Endpoint_Write_Control_PStream_LE+0x26>
			static inline uint16_t Endpoint_BytesInEndpoint(void)
			{
				#if (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
					return UEBCX;
				#elif defined(USB_SERIES_4_AVR)
					return (((uint16_t)UEBCHX << 8) | UEBCLX);
     4ce:	20 91 f3 00 	lds	r18, 0x00F3	; 0x8000f3 <__TEXT_REGION_LENGTH__+0x7e00f3>
     4d2:	80 91 f2 00 	lds	r24, 0x00F2	; 0x8000f2 <__TEXT_REGION_LENGTH__+0x7e00f2>
     4d6:	90 e0       	ldi	r25, 0x00	; 0
     4d8:	92 2b       	or	r25, r18
		{
			uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();

			while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
     4da:	61 15       	cp	r22, r1
     4dc:	71 05       	cpc	r23, r1
     4de:	59 f0       	breq	.+22     	; 0x4f6 <Endpoint_Write_Control_PStream_LE+0x7c>
     4e0:	88 30       	cpi	r24, 0x08	; 8
     4e2:	91 05       	cpc	r25, r1
     4e4:	40 f4       	brcc	.+16     	; 0x4f6 <Endpoint_Write_Control_PStream_LE+0x7c>
			{
				TEMPLATE_TRANSFER_BYTE(DataStream);
     4e6:	24 91       	lpm	r18, Z
			 *  \param[in] Data  Data to write into the the currently selected endpoint's FIFO buffer.
			 */
			static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_Write_8(const uint8_t Data)
			{
				UEDATX = Data;
     4e8:	20 93 f1 00 	sts	0x00F1, r18	; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1>
				TEMPLATE_BUFFER_MOVE(DataStream, 1);
     4ec:	31 96       	adiw	r30, 0x01	; 1
				Length--;
     4ee:	61 50       	subi	r22, 0x01	; 1
     4f0:	71 09       	sbc	r23, r1
				BytesInEndpoint++;
     4f2:	01 96       	adiw	r24, 0x01	; 1
     4f4:	f2 cf       	rjmp	.-28     	; 0x4da <Endpoint_Write_Control_PStream_LE+0x60>
			}

			LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
     4f6:	21 e0       	ldi	r18, 0x01	; 1
     4f8:	08 97       	sbiw	r24, 0x08	; 8
     4fa:	09 f0       	breq	.+2      	; 0x4fe <Endpoint_Write_Control_PStream_LE+0x84>
     4fc:	20 e0       	ldi	r18, 0x00	; 0
			 */
			static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearIN(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
     4fe:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     502:	8e 77       	andi	r24, 0x7E	; 126
     504:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     508:	cb cf       	rjmp	.-106    	; 0x4a0 <Endpoint_Write_Control_PStream_LE+0x26>
	if (Length > USB_ControlRequest.wLength)
	  Length = USB_ControlRequest.wLength;
	else if (!(Length))
	  Endpoint_ClearIN();

	while (Length || LastPacketFull)
     50a:	21 11       	cpse	r18, r1
     50c:	cc cf       	rjmp	.-104    	; 0x4a6 <Endpoint_Write_Control_PStream_LE+0x2c>
     50e:	0a c0       	rjmp	.+20     	; 0x524 <Endpoint_Write_Control_PStream_LE+0xaa>
		}
	}

	while (!(Endpoint_IsOUTReceived()))
	{
		uint8_t USB_DeviceState_LCL = USB_DeviceState;
     510:	80 91 18 01 	lds	r24, 0x0118	; 0x800118 <USB_DeviceState>

		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
     514:	88 23       	and	r24, r24
     516:	61 f0       	breq	.+24     	; 0x530 <Endpoint_Write_Control_PStream_LE+0xb6>
		  return ENDPOINT_RWCSTREAM_DeviceDisconnected;
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
     518:	85 30       	cpi	r24, 0x05	; 5
     51a:	61 f0       	breq	.+24     	; 0x534 <Endpoint_Write_Control_PStream_LE+0xba>
			 *  \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsSETUPReceived(void)
			{
				return ((UEINTX & (1 << RXSTPI)) ? true : false);
     51c:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
		  return ENDPOINT_RWCSTREAM_BusSuspended;
		else if (Endpoint_IsSETUPReceived())
     520:	83 fd       	sbrc	r24, 3
     522:	0a c0       	rjmp	.+20     	; 0x538 <Endpoint_Write_Control_PStream_LE+0xbe>
			 *  \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsOUTReceived(void)
			{
				return ((UEINTX & (1 << RXOUTI)) ? true : false);
     524:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
			LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
			Endpoint_ClearIN();
		}
	}

	while (!(Endpoint_IsOUTReceived()))
     528:	82 ff       	sbrs	r24, 2
     52a:	f2 cf       	rjmp	.-28     	; 0x510 <Endpoint_Write_Control_PStream_LE+0x96>
		  return ENDPOINT_RWCSTREAM_BusSuspended;
		else if (Endpoint_IsSETUPReceived())
		  return ENDPOINT_RWCSTREAM_HostAborted;
	}

	return ENDPOINT_RWCSTREAM_NoError;
     52c:	80 e0       	ldi	r24, 0x00	; 0
     52e:	08 95       	ret
	while (Length || LastPacketFull)
	{
		uint8_t USB_DeviceState_LCL = USB_DeviceState;

		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
		  return ENDPOINT_RWCSTREAM_DeviceDisconnected;
     530:	82 e0       	ldi	r24, 0x02	; 2
     532:	08 95       	ret
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
		  return ENDPOINT_RWCSTREAM_BusSuspended;
     534:	83 e0       	ldi	r24, 0x03	; 3
     536:	08 95       	ret
		else if (Endpoint_IsSETUPReceived())
		  return ENDPOINT_RWCSTREAM_HostAborted;
     538:	81 e0       	ldi	r24, 0x01	; 1
		else if (Endpoint_IsSETUPReceived())
		  return ENDPOINT_RWCSTREAM_HostAborted;
	}

	return ENDPOINT_RWCSTREAM_NoError;
}
     53a:	08 95       	ret

0000053c <Endpoint_ConfigureEndpoint_Prv>:
		UEIENX  = 0;
		UEINTX  = 0;
		UECFG1X = 0;
		Endpoint_DisableEndpoint();
	}
}
     53c:	98 2f       	mov	r25, r24
     53e:	97 30       	cpi	r25, 0x07	; 7
     540:	68 f5       	brcc	.+90     	; 0x59c <Endpoint_ConfigureEndpoint_Prv+0x60>
     542:	90 93 e9 00 	sts	0x00E9, r25	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>
     546:	98 17       	cp	r25, r24
     548:	39 f0       	breq	.+14     	; 0x558 <Endpoint_ConfigureEndpoint_Prv+0x1c>
     54a:	70 91 ec 00 	lds	r23, 0x00EC	; 0x8000ec <__TEXT_REGION_LENGTH__+0x7e00ec>
     54e:	20 91 ed 00 	lds	r18, 0x00ED	; 0x8000ed <__TEXT_REGION_LENGTH__+0x7e00ed>
     552:	50 91 f0 00 	lds	r21, 0x00F0	; 0x8000f0 <__TEXT_REGION_LENGTH__+0x7e00f0>
     556:	03 c0       	rjmp	.+6      	; 0x55e <Endpoint_ConfigureEndpoint_Prv+0x22>
     558:	24 2f       	mov	r18, r20
     55a:	76 2f       	mov	r23, r22
     55c:	50 e0       	ldi	r21, 0x00	; 0
     55e:	21 fd       	sbrc	r18, 1
     560:	02 c0       	rjmp	.+4      	; 0x566 <Endpoint_ConfigureEndpoint_Prv+0x2a>
     562:	9f 5f       	subi	r25, 0xFF	; 255
     564:	ec cf       	rjmp	.-40     	; 0x53e <Endpoint_ConfigureEndpoint_Prv+0x2>
     566:	30 91 eb 00 	lds	r19, 0x00EB	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
     56a:	3e 7f       	andi	r19, 0xFE	; 254
     56c:	30 93 eb 00 	sts	0x00EB, r19	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
     570:	30 91 ed 00 	lds	r19, 0x00ED	; 0x8000ed <__TEXT_REGION_LENGTH__+0x7e00ed>
     574:	3d 7f       	andi	r19, 0xFD	; 253
     576:	30 93 ed 00 	sts	0x00ED, r19	; 0x8000ed <__TEXT_REGION_LENGTH__+0x7e00ed>
     57a:	30 91 eb 00 	lds	r19, 0x00EB	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
     57e:	31 60       	ori	r19, 0x01	; 1
     580:	30 93 eb 00 	sts	0x00EB, r19	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
     584:	70 93 ec 00 	sts	0x00EC, r23	; 0x8000ec <__TEXT_REGION_LENGTH__+0x7e00ec>
     588:	20 93 ed 00 	sts	0x00ED, r18	; 0x8000ed <__TEXT_REGION_LENGTH__+0x7e00ed>
     58c:	50 93 f0 00 	sts	0x00F0, r21	; 0x8000f0 <__TEXT_REGION_LENGTH__+0x7e00f0>
     590:	20 91 ee 00 	lds	r18, 0x00EE	; 0x8000ee <__TEXT_REGION_LENGTH__+0x7e00ee>
     594:	27 fd       	sbrc	r18, 7
     596:	e5 cf       	rjmp	.-54     	; 0x562 <Endpoint_ConfigureEndpoint_Prv+0x26>
     598:	80 e0       	ldi	r24, 0x00	; 0
     59a:	08 95       	ret
     59c:	8f 70       	andi	r24, 0x0F	; 15
     59e:	80 93 e9 00 	sts	0x00E9, r24	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>
     5a2:	81 e0       	ldi	r24, 0x01	; 1
     5a4:	08 95       	ret

000005a6 <Endpoint_ConfigureEndpointTable>:
     5a6:	0f 93       	push	r16
     5a8:	1f 93       	push	r17
     5aa:	cf 93       	push	r28
     5ac:	df 93       	push	r29
     5ae:	06 2f       	mov	r16, r22
     5b0:	ec 01       	movw	r28, r24
     5b2:	10 e0       	ldi	r17, 0x00	; 0
     5b4:	10 17       	cp	r17, r16
     5b6:	71 f1       	breq	.+92     	; 0x614 <Endpoint_ConfigureEndpointTable+0x6e>
     5b8:	68 81       	ld	r22, Y
     5ba:	61 11       	cpse	r22, r1
     5bc:	03 c0       	rjmp	.+6      	; 0x5c4 <Endpoint_ConfigureEndpointTable+0x1e>
     5be:	1f 5f       	subi	r17, 0xFF	; 255
     5c0:	25 96       	adiw	r28, 0x05	; 5
     5c2:	f8 cf       	rjmp	.-16     	; 0x5b4 <Endpoint_ConfigureEndpointTable+0xe>
     5c4:	2c 81       	ldd	r18, Y+4	; 0x04
     5c6:	a9 81       	ldd	r26, Y+1	; 0x01
     5c8:	ba 81       	ldd	r27, Y+2	; 0x02
     5ca:	9b 81       	ldd	r25, Y+3	; 0x03
     5cc:	86 2f       	mov	r24, r22
     5ce:	8f 70       	andi	r24, 0x0F	; 15
     5d0:	87 30       	cpi	r24, 0x07	; 7
     5d2:	10 f0       	brcs	.+4      	; 0x5d8 <Endpoint_ConfigureEndpointTable+0x32>
     5d4:	80 e0       	ldi	r24, 0x00	; 0
     5d6:	1f c0       	rjmp	.+62     	; 0x616 <Endpoint_ConfigureEndpointTable+0x70>
     5d8:	22 30       	cpi	r18, 0x02	; 2
     5da:	10 f4       	brcc	.+4      	; 0x5e0 <Endpoint_ConfigureEndpointTable+0x3a>
     5dc:	42 e0       	ldi	r20, 0x02	; 2
     5de:	01 c0       	rjmp	.+2      	; 0x5e2 <Endpoint_ConfigureEndpointTable+0x3c>
     5e0:	46 e0       	ldi	r20, 0x06	; 6
     5e2:	e8 e0       	ldi	r30, 0x08	; 8
     5e4:	f0 e0       	ldi	r31, 0x00	; 0
     5e6:	20 e0       	ldi	r18, 0x00	; 0
     5e8:	ea 17       	cp	r30, r26
     5ea:	fb 07       	cpc	r31, r27
     5ec:	20 f4       	brcc	.+8      	; 0x5f6 <Endpoint_ConfigureEndpointTable+0x50>
     5ee:	2f 5f       	subi	r18, 0xFF	; 255
     5f0:	ee 0f       	add	r30, r30
     5f2:	ff 1f       	adc	r31, r31
     5f4:	f9 cf       	rjmp	.-14     	; 0x5e8 <Endpoint_ConfigureEndpointTable+0x42>
     5f6:	22 95       	swap	r18
     5f8:	20 7f       	andi	r18, 0xF0	; 240
     5fa:	42 2b       	or	r20, r18
     5fc:	50 e4       	ldi	r21, 0x40	; 64
     5fe:	95 9f       	mul	r25, r21
     600:	90 01       	movw	r18, r0
     602:	11 24       	eor	r1, r1
     604:	66 1f       	adc	r22, r22
     606:	66 27       	eor	r22, r22
     608:	66 1f       	adc	r22, r22
     60a:	62 2b       	or	r22, r18
     60c:	97 df       	rcall	.-210    	; 0x53c <Endpoint_ConfigureEndpoint_Prv>
     60e:	81 11       	cpse	r24, r1
     610:	d6 cf       	rjmp	.-84     	; 0x5be <Endpoint_ConfigureEndpointTable+0x18>
     612:	e0 cf       	rjmp	.-64     	; 0x5d4 <Endpoint_ConfigureEndpointTable+0x2e>
     614:	81 e0       	ldi	r24, 0x01	; 1
     616:	df 91       	pop	r29
     618:	cf 91       	pop	r28
     61a:	1f 91       	pop	r17
     61c:	0f 91       	pop	r16
     61e:	08 95       	ret

00000620 <Endpoint_ClearStatusStage>:

void Endpoint_ClearStatusStage(void)
{
	if (USB_ControlRequest.bmRequestType & REQDIR_DEVICETOHOST)
     620:	80 91 19 01 	lds	r24, 0x0119	; 0x800119 <USB_ControlRequest>
     624:	87 ff       	sbrs	r24, 7
     626:	11 c0       	rjmp	.+34     	; 0x64a <Endpoint_ClearStatusStage+0x2a>
			 *  \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsOUTReceived(void)
			{
				return ((UEINTX & (1 << RXOUTI)) ? true : false);
     628:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
	{
		while (!(Endpoint_IsOUTReceived()))
     62c:	82 fd       	sbrc	r24, 2
     62e:	05 c0       	rjmp	.+10     	; 0x63a <Endpoint_ClearStatusStage+0x1a>
		{
			if (USB_DeviceState == DEVICE_STATE_Unattached)
     630:	80 91 18 01 	lds	r24, 0x0118	; 0x800118 <USB_DeviceState>
     634:	81 11       	cpse	r24, r1
     636:	f8 cf       	rjmp	.-16     	; 0x628 <Endpoint_ClearStatusStage+0x8>
     638:	11 c0       	rjmp	.+34     	; 0x65c <Endpoint_ClearStatusStage+0x3c>
			 */
			static inline void Endpoint_ClearOUT(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearOUT(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UEINTX &= ~((1 << RXOUTI) | (1 << FIFOCON));
     63a:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     63e:	8b 77       	andi	r24, 0x7B	; 123
     640:	0b c0       	rjmp	.+22     	; 0x658 <Endpoint_ClearStatusStage+0x38>
	}
	else
	{
		while (!(Endpoint_IsINReady()))
		{
			if (USB_DeviceState == DEVICE_STATE_Unattached)
     642:	80 91 18 01 	lds	r24, 0x0118	; 0x800118 <USB_DeviceState>
     646:	88 23       	and	r24, r24
     648:	49 f0       	breq	.+18     	; 0x65c <Endpoint_ClearStatusStage+0x3c>
			 *  \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsINReady(void)
			{
				return ((UEINTX & (1 << TXINI)) ? true : false);
     64a:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>

		Endpoint_ClearOUT();
	}
	else
	{
		while (!(Endpoint_IsINReady()))
     64e:	80 ff       	sbrs	r24, 0
     650:	f8 cf       	rjmp	.-16     	; 0x642 <Endpoint_ClearStatusStage+0x22>
			 */
			static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearIN(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
     652:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     656:	8e 77       	andi	r24, 0x7E	; 126
     658:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     65c:	08 95       	ret

0000065e <Endpoint_WaitUntilReady>:
			 *  \return Current USB frame number from the USB controller.
			 */
			static inline uint16_t USB_Device_GetFrameNumber(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
			static inline uint16_t USB_Device_GetFrameNumber(void)
			{
				return UDFNUM;
     65e:	20 91 e4 00 	lds	r18, 0x00E4	; 0x8000e4 <__TEXT_REGION_LENGTH__+0x7e00e4>
     662:	30 91 e5 00 	lds	r19, 0x00E5	; 0x8000e5 <__TEXT_REGION_LENGTH__+0x7e00e5>
     666:	95 e6       	ldi	r25, 0x65	; 101
			 *  \return The currently selected endpoint's direction, as a \c ENDPOINT_DIR_* mask.
			 */
			static inline uint8_t Endpoint_GetEndpointDirection(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline uint8_t Endpoint_GetEndpointDirection(void)
			{
				return (UECFG0X & (1 << EPDIR)) ? ENDPOINT_DIR_IN : ENDPOINT_DIR_OUT;
     668:	40 91 ec 00 	lds	r20, 0x00EC	; 0x8000ec <__TEXT_REGION_LENGTH__+0x7e00ec>
     66c:	84 2f       	mov	r24, r20
     66e:	81 70       	andi	r24, 0x01	; 1
     670:	40 ff       	sbrs	r20, 0
     672:	23 c0       	rjmp	.+70     	; 0x6ba <Endpoint_WaitUntilReady+0x5c>
			 *  \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsINReady(void)
			{
				return ((UEINTX & (1 << TXINI)) ? true : false);
     674:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>

	for (;;)
	{
		if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
		{
			if (Endpoint_IsINReady())
     678:	80 fd       	sbrc	r24, 0
     67a:	1d c0       	rjmp	.+58     	; 0x6b6 <Endpoint_WaitUntilReady+0x58>
		{
			if (Endpoint_IsOUTReceived())
			  return ENDPOINT_READYWAIT_NoError;
		}

		uint8_t USB_DeviceState_LCL = USB_DeviceState;
     67c:	80 91 18 01 	lds	r24, 0x0118	; 0x800118 <USB_DeviceState>

		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
     680:	88 23       	and	r24, r24
     682:	99 f0       	breq	.+38     	; 0x6aa <Endpoint_WaitUntilReady+0x4c>
		  return ENDPOINT_READYWAIT_DeviceDisconnected;
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
     684:	85 30       	cpi	r24, 0x05	; 5
     686:	99 f0       	breq	.+38     	; 0x6ae <Endpoint_WaitUntilReady+0x50>
			 *  \return Boolean \c true if the currently selected endpoint is stalled, \c false otherwise.
			 */
			static inline bool Endpoint_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsStalled(void)
			{
				return ((UECONX & (1 << STALLRQ)) ? true : false);
     688:	80 91 eb 00 	lds	r24, 0x00EB	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
		  return ENDPOINT_READYWAIT_BusSuspended;
		else if (Endpoint_IsStalled())
     68c:	85 fd       	sbrc	r24, 5
     68e:	11 c0       	rjmp	.+34     	; 0x6b2 <Endpoint_WaitUntilReady+0x54>
     690:	40 91 e4 00 	lds	r20, 0x00E4	; 0x8000e4 <__TEXT_REGION_LENGTH__+0x7e00e4>
     694:	50 91 e5 00 	lds	r21, 0x00E5	; 0x8000e5 <__TEXT_REGION_LENGTH__+0x7e00e5>
		  return ENDPOINT_READYWAIT_EndpointStalled;

		uint16_t CurrentFrameNumber = USB_Device_GetFrameNumber();

		if (CurrentFrameNumber != PreviousFrameNumber)
     698:	24 17       	cp	r18, r20
     69a:	35 07       	cpc	r19, r21
     69c:	29 f3       	breq	.-54     	; 0x668 <Endpoint_WaitUntilReady+0xa>
     69e:	91 50       	subi	r25, 0x01	; 1
		{
			PreviousFrameNumber = CurrentFrameNumber;

			if (!(TimeoutMSRem--))
     6a0:	11 f0       	breq	.+4      	; 0x6a6 <Endpoint_WaitUntilReady+0x48>
     6a2:	9a 01       	movw	r18, r20
     6a4:	e1 cf       	rjmp	.-62     	; 0x668 <Endpoint_WaitUntilReady+0xa>
			  return ENDPOINT_READYWAIT_Timeout;
     6a6:	84 e0       	ldi	r24, 0x04	; 4
     6a8:	08 95       	ret
		}

		uint8_t USB_DeviceState_LCL = USB_DeviceState;

		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
		  return ENDPOINT_READYWAIT_DeviceDisconnected;
     6aa:	82 e0       	ldi	r24, 0x02	; 2
     6ac:	08 95       	ret
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
		  return ENDPOINT_READYWAIT_BusSuspended;
     6ae:	83 e0       	ldi	r24, 0x03	; 3
     6b0:	08 95       	ret
		else if (Endpoint_IsStalled())
		  return ENDPOINT_READYWAIT_EndpointStalled;
     6b2:	81 e0       	ldi	r24, 0x01	; 1
     6b4:	08 95       	ret
	for (;;)
	{
		if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
		{
			if (Endpoint_IsINReady())
			  return ENDPOINT_READYWAIT_NoError;
     6b6:	80 e0       	ldi	r24, 0x00	; 0
     6b8:	08 95       	ret
			 *  \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsOUTReceived(void)
			{
				return ((UEINTX & (1 << RXOUTI)) ? true : false);
     6ba:	40 91 e8 00 	lds	r20, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
		}
		else
		{
			if (Endpoint_IsOUTReceived())
     6be:	42 ff       	sbrs	r20, 2
     6c0:	dd cf       	rjmp	.-70     	; 0x67c <Endpoint_WaitUntilReady+0x1e>

			if (!(TimeoutMSRem--))
			  return ENDPOINT_READYWAIT_Timeout;
		}
	}
}
     6c2:	08 95       	ret

000006c4 <USB_ResetInterface>:

	USB_IsInitialized = false;
}

void USB_ResetInterface(void)
{
     6c4:	0f 93       	push	r16
     6c6:	1f 93       	push	r17
     6c8:	cf 93       	push	r28
     6ca:	df 93       	push	r29
	#if defined(USB_CAN_BE_BOTH)
	bool UIDModeSelectEnabled = ((UHWCON & (1 << UIDE)) != 0);
	#endif

	USB_INT_DisableAllInterrupts();
     6cc:	4b d0       	rcall	.+150    	; 0x764 <USB_INT_DisableAllInterrupts>
	USB_INT_ClearAllInterrupts();
     6ce:	52 d0       	rcall	.+164    	; 0x774 <USB_INT_ClearAllInterrupts>
     6d0:	c8 ed       	ldi	r28, 0xD8	; 216
			}

			static inline void USB_Controller_Reset(void) ATTR_ALWAYS_INLINE;
			static inline void USB_Controller_Reset(void)
			{
				USBCON &= ~(1 << USBE);
     6d2:	d0 e0       	ldi	r29, 0x00	; 0
     6d4:	88 81       	ld	r24, Y
     6d6:	8f 77       	andi	r24, 0x7F	; 127
     6d8:	88 83       	st	Y, r24
     6da:	88 81       	ld	r24, Y
				USBCON |=  (1 << USBE);
     6dc:	80 68       	ori	r24, 0x80	; 128
     6de:	88 83       	st	Y, r24
     6e0:	88 81       	ld	r24, Y
			}

			static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE;
			static inline void USB_CLK_Unfreeze(void)
			{
				USBCON &= ~(1 << FRZCLK);
     6e2:	8f 7d       	andi	r24, 0xDF	; 223
     6e4:	88 83       	st	Y, r24
     6e6:	19 bc       	out	0x29, r1	; 41
			}

			static inline void USB_PLL_Off(void) ATTR_ALWAYS_INLINE;
			static inline void USB_PLL_Off(void)
			{
				PLLCSR = 0;
     6e8:	10 92 18 01 	sts	0x0118, r1	; 0x800118 <USB_DeviceState>
}

#if defined(USB_CAN_BE_DEVICE)
static void USB_Init_Device(void)
{
	USB_DeviceState                 = DEVICE_STATE_Unattached;
     6ec:	10 92 14 01 	sts	0x0114, r1	; 0x800114 <USB_Device_ConfigurationNumber>
	USB_Device_ConfigurationNumber  = 0;
     6f0:	10 92 16 01 	sts	0x0116, r1	; 0x800116 <USB_Device_RemoteWakeupEnabled>

	#if !defined(NO_DEVICE_REMOTE_WAKEUP)
	USB_Device_RemoteWakeupEnabled  = false;
     6f4:	10 92 15 01 	sts	0x0115, r1	; 0x800115 <USB_Device_CurrentlySelfPowered>
	#endif

	#if !defined(NO_DEVICE_SELF_POWER)
	USB_Device_CurrentlySelfPowered = false;
     6f8:	00 ee       	ldi	r16, 0xE0	; 224
			}

			static inline void USB_Device_SetFullSpeed(void) ATTR_ALWAYS_INLINE;
			static inline void USB_Device_SetFullSpeed(void)
			{
				UDCON &= ~(1 << LSM);
     6fa:	10 e0       	ldi	r17, 0x00	; 0
     6fc:	f8 01       	movw	r30, r16
     6fe:	80 81       	ld	r24, Z
     700:	8b 7f       	andi	r24, 0xFB	; 251
     702:	80 83       	st	Z, r24
     704:	88 81       	ld	r24, Y
			{
				switch (Interrupt)
				{
					#if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
					case USB_INT_VBUSTI:
						USBCON |= (1 << VBUSTE);
     706:	81 60       	ori	r24, 0x01	; 1
     708:	88 83       	st	Y, r24
     70a:	42 e0       	ldi	r20, 0x02	; 2
				uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);

				if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
				  return false;

				return Endpoint_ConfigureEndpoint_Prv(Number,
     70c:	60 e0       	ldi	r22, 0x00	; 0
     70e:	80 e0       	ldi	r24, 0x00	; 0
     710:	15 df       	rcall	.-470    	; 0x53c <Endpoint_ConfigureEndpoint_Prv>
     712:	e1 ee       	ldi	r30, 0xE1	; 225
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDINT  &= ~(1 << WAKEUPI);
						break;
					case USB_INT_SUSPI:
						UDINT  &= ~(1 << SUSPI);
     714:	f0 e0       	ldi	r31, 0x00	; 0
     716:	80 81       	ld	r24, Z
     718:	8e 7f       	andi	r24, 0xFE	; 254
     71a:	80 83       	st	Z, r24
     71c:	e2 ee       	ldi	r30, 0xE2	; 226
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  |= (1 << WAKEUPE);
						break;
					case USB_INT_SUSPI:
						UDIEN  |= (1 << SUSPE);
     71e:	f0 e0       	ldi	r31, 0x00	; 0
     720:	80 81       	ld	r24, Z
     722:	81 60       	ori	r24, 0x01	; 1
     724:	80 83       	st	Z, r24
     726:	80 81       	ld	r24, Z
						break;
					case USB_INT_EORSTI:
						UDIEN  |= (1 << EORSTE);
     728:	88 60       	ori	r24, 0x08	; 8
     72a:	80 83       	st	Z, r24
     72c:	f8 01       	movw	r30, r16
			 *  register and despite the datasheet making no mention of its requirement in host mode.
			 */
			static inline void USB_Attach(void) ATTR_ALWAYS_INLINE;
			static inline void USB_Attach(void)
			{
				UDCON  &= ~(1 << DETACH);
     72e:	80 81       	ld	r24, Z
     730:	8e 7f       	andi	r24, 0xFE	; 254
     732:	80 83       	st	Z, r24
     734:	88 81       	ld	r24, Y

			#if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
			static inline void USB_OTGPAD_On(void) ATTR_ALWAYS_INLINE;
			static inline void USB_OTGPAD_On(void)
			{
				USBCON |=  (1 << OTGPADE);
     736:	80 61       	ori	r24, 0x10	; 16
     738:	88 83       	st	Y, r24
     73a:	df 91       	pop	r29
	}

	#if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
	USB_OTGPAD_On();
	#endif
}
     73c:	cf 91       	pop	r28
     73e:	1f 91       	pop	r17
     740:	0f 91       	pop	r16
     742:	08 95       	ret

00000744 <USB_Init>:
     744:	e8 ed       	ldi	r30, 0xD8	; 216
			}

			static inline void USB_OTGPAD_Off(void) ATTR_ALWAYS_INLINE;
			static inline void USB_OTGPAD_Off(void)
			{
				USBCON &= ~(1 << OTGPADE);
     746:	f0 e0       	ldi	r31, 0x00	; 0
     748:	80 81       	ld	r24, Z
     74a:	8f 7e       	andi	r24, 0xEF	; 239
     74c:	80 83       	st	Z, r24

			static inline void USB_REG_On(void) ATTR_ALWAYS_INLINE;
			static inline void USB_REG_On(void)
			{
			#if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
				UHWCON |=  (1 << UVREGE);
     74e:	e7 ed       	ldi	r30, 0xD7	; 215
     750:	f0 e0       	ldi	r31, 0x00	; 0
     752:	80 81       	ld	r24, Z
     754:	81 60       	ori	r24, 0x01	; 1
     756:	80 83       	st	Z, r24
	  USB_REG_Off();

	if (!(USB_Options & USB_OPT_MANUAL_PLL))
	{
		#if defined(USB_SERIES_4_AVR)
		PLLFRQ = (1 << PDIV2);
     758:	84 e0       	ldi	r24, 0x04	; 4
     75a:	82 bf       	out	0x32, r24	; 50
		UHWCON &= ~(1 << UIDE);
		USB_CurrentMode = Mode;
	}
	#endif

	USB_IsInitialized = true;
     75c:	81 e0       	ldi	r24, 0x01	; 1
     75e:	80 93 17 01 	sts	0x0117, r24	; 0x800117 <USB_IsInitialized>

	USB_ResetInterface();
     762:	b0 cf       	rjmp	.-160    	; 0x6c4 <USB_ResetInterface>

00000764 <USB_INT_DisableAllInterrupts>:
void USB_INT_DisableAllInterrupts(void)
{
	#if defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
	USBCON &= ~((1 << VBUSTE) | (1 << IDTE));
	#elif defined(USB_SERIES_4_AVR)
	USBCON &= ~(1 << VBUSTE);
     764:	e8 ed       	ldi	r30, 0xD8	; 216
     766:	f0 e0       	ldi	r31, 0x00	; 0
     768:	80 81       	ld	r24, Z
     76a:	8e 7f       	andi	r24, 0xFE	; 254
     76c:	80 83       	st	Z, r24
	#if defined(USB_CAN_BE_HOST)
	UHIEN   = 0;
	#endif

	#if defined(USB_CAN_BE_DEVICE)
	UDIEN   = 0;
     76e:	10 92 e2 00 	sts	0x00E2, r1	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
     772:	08 95       	ret

00000774 <USB_INT_ClearAllInterrupts>:
}

void USB_INT_ClearAllInterrupts(void)
{
	#if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
	USBINT = 0;
     774:	10 92 da 00 	sts	0x00DA, r1	; 0x8000da <__TEXT_REGION_LENGTH__+0x7e00da>
	#if defined(USB_CAN_BE_HOST)
	UHINT  = 0;
	#endif

	#if defined(USB_CAN_BE_DEVICE)
	UDINT  = 0;
     778:	10 92 e1 00 	sts	0x00E1, r1	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
     77c:	08 95       	ret

0000077e <__vector_10>:
	#endif
}

ISR(USB_GEN_vect, ISR_BLOCK)
{
     77e:	1f 92       	push	r1
     780:	0f 92       	push	r0
     782:	0f b6       	in	r0, 0x3f	; 63
     784:	0f 92       	push	r0
     786:	11 24       	eor	r1, r1
     788:	2f 93       	push	r18
     78a:	3f 93       	push	r19
     78c:	4f 93       	push	r20
     78e:	5f 93       	push	r21
     790:	6f 93       	push	r22
     792:	7f 93       	push	r23
     794:	8f 93       	push	r24
     796:	9f 93       	push	r25
     798:	af 93       	push	r26
     79a:	bf 93       	push	r27
     79c:	ef 93       	push	r30
     79e:	ff 93       	push	r31
					case USB_INT_SUSPI:
						return (UDINT  & (1 << SUSPI));
					case USB_INT_EORSTI:
						return (UDINT  & (1 << EORSTI));
					case USB_INT_SOFI:
						return (UDINT  & (1 << SOFI));
     7a0:	80 91 e1 00 	lds	r24, 0x00E1	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
	#if defined(USB_CAN_BE_DEVICE)
	#if !defined(NO_SOF_EVENTS)
	if (USB_INT_HasOccurred(USB_INT_SOFI) && USB_INT_IsEnabled(USB_INT_SOFI))
     7a4:	82 ff       	sbrs	r24, 2
     7a6:	0a c0       	rjmp	.+20     	; 0x7bc <__vector_10+0x3e>
					case USB_INT_SUSPI:
						return (UDIEN  & (1 << SUSPE));
					case USB_INT_EORSTI:
						return (UDIEN  & (1 << EORSTE));
					case USB_INT_SOFI:
						return (UDIEN  & (1 << SOFE));
     7a8:	80 91 e2 00 	lds	r24, 0x00E2	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
     7ac:	82 ff       	sbrs	r24, 2
     7ae:	06 c0       	rjmp	.+12     	; 0x7bc <__vector_10+0x3e>
						break;
					case USB_INT_EORSTI:
						UDINT  &= ~(1 << EORSTI);
						break;
					case USB_INT_SOFI:
						UDINT  &= ~(1 << SOFI);
     7b0:	80 91 e1 00 	lds	r24, 0x00E1	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
     7b4:	8b 7f       	andi	r24, 0xFB	; 251
     7b6:	80 93 e1 00 	sts	0x00E1, r24	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
	{
		USB_INT_Clear(USB_INT_SOFI);

		EVENT_USB_Device_StartOfFrame();
     7ba:	1e dd       	rcall	.-1476   	; 0x1f8 <EVENT_USB_Device_StartOfFrame>
			{
				switch (Interrupt)
				{
					#if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
					case USB_INT_VBUSTI:
						return (USBINT & (1 << VBUSTI));
     7bc:	80 91 da 00 	lds	r24, 0x00DA	; 0x8000da <__TEXT_REGION_LENGTH__+0x7e00da>
	}
	#endif

	#if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
	if (USB_INT_HasOccurred(USB_INT_VBUSTI) && USB_INT_IsEnabled(USB_INT_VBUSTI))
     7c0:	80 ff       	sbrs	r24, 0
     7c2:	1d c0       	rjmp	.+58     	; 0x7fe <__vector_10+0x80>
			{
				switch (Interrupt)
				{
					#if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
					case USB_INT_VBUSTI:
						return (USBCON & (1 << VBUSTE));
     7c4:	80 91 d8 00 	lds	r24, 0x00D8	; 0x8000d8 <__TEXT_REGION_LENGTH__+0x7e00d8>
     7c8:	80 ff       	sbrs	r24, 0
     7ca:	19 c0       	rjmp	.+50     	; 0x7fe <__vector_10+0x80>
			{
				switch (Interrupt)
				{
					#if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
					case USB_INT_VBUSTI:
						USBINT &= ~(1 << VBUSTI);
     7cc:	80 91 da 00 	lds	r24, 0x00DA	; 0x8000da <__TEXT_REGION_LENGTH__+0x7e00da>
     7d0:	8e 7f       	andi	r24, 0xFE	; 254
     7d2:	80 93 da 00 	sts	0x00DA, r24	; 0x8000da <__TEXT_REGION_LENGTH__+0x7e00da>
				 *  \return Boolean \c true if the VBUS line is currently detecting power from a host, \c false otherwise.
				 */
				static inline bool USB_VBUS_GetStatus(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
				static inline bool USB_VBUS_GetStatus(void)
				{
					return ((USBSTA & (1 << VBUS)) ? true : false);
     7d6:	80 91 d9 00 	lds	r24, 0x00D9	; 0x8000d9 <__TEXT_REGION_LENGTH__+0x7e00d9>
	{
		USB_INT_Clear(USB_INT_VBUSTI);

		if (USB_VBUS_GetStatus())
     7da:	80 ff       	sbrs	r24, 0
     7dc:	0c c0       	rjmp	.+24     	; 0x7f6 <__vector_10+0x78>

		/* Inline Functions: */
			static inline void USB_PLL_On(void) ATTR_ALWAYS_INLINE;
			static inline void USB_PLL_On(void)
			{
				PLLCSR = USB_PLL_PSC;
     7de:	80 e1       	ldi	r24, 0x10	; 16
     7e0:	89 bd       	out	0x29, r24	; 41
				PLLCSR = (USB_PLL_PSC | (1 << PLLE));
     7e2:	82 e1       	ldi	r24, 0x12	; 18
     7e4:	89 bd       	out	0x29, r24	; 41
		{
			if (!(USB_Options & USB_OPT_MANUAL_PLL))
			{
				USB_PLL_On();
				while (!(USB_PLL_IsReady()));
     7e6:	09 b4       	in	r0, 0x29	; 41
     7e8:	00 fe       	sbrs	r0, 0
     7ea:	fd cf       	rjmp	.-6      	; 0x7e6 <__vector_10+0x68>
			}

			USB_DeviceState = DEVICE_STATE_Powered;
     7ec:	81 e0       	ldi	r24, 0x01	; 1
     7ee:	80 93 18 01 	sts	0x0118, r24	; 0x800118 <USB_DeviceState>
			EVENT_USB_Device_Connect();
     7f2:	f4 dc       	rcall	.-1560   	; 0x1dc <EVENT_USB_Device_Connect>
     7f4:	04 c0       	rjmp	.+8      	; 0x7fe <__vector_10+0x80>
			}

			static inline void USB_PLL_Off(void) ATTR_ALWAYS_INLINE;
			static inline void USB_PLL_Off(void)
			{
				PLLCSR = 0;
     7f6:	19 bc       	out	0x29, r1	; 41
		else
		{
			if (!(USB_Options & USB_OPT_MANUAL_PLL))
			  USB_PLL_Off();

			USB_DeviceState = DEVICE_STATE_Unattached;
     7f8:	10 92 18 01 	sts	0x0118, r1	; 0x800118 <USB_DeviceState>
			EVENT_USB_Device_Disconnect();
     7fc:	f0 dc       	rcall	.-1568   	; 0x1de <EVENT_USB_Device_Disconnect>
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						return (UDINT  & (1 << WAKEUPI));
					case USB_INT_SUSPI:
						return (UDINT  & (1 << SUSPI));
     7fe:	80 91 e1 00 	lds	r24, 0x00E1	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
		}
	}
	#endif

	if (USB_INT_HasOccurred(USB_INT_SUSPI) && USB_INT_IsEnabled(USB_INT_SUSPI))
     802:	80 ff       	sbrs	r24, 0
     804:	18 c0       	rjmp	.+48     	; 0x836 <__vector_10+0xb8>
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						return (UDIEN  & (1 << WAKEUPE));
					case USB_INT_SUSPI:
						return (UDIEN  & (1 << SUSPE));
     806:	80 91 e2 00 	lds	r24, 0x00E2	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
     80a:	80 ff       	sbrs	r24, 0
     80c:	14 c0       	rjmp	.+40     	; 0x836 <__vector_10+0xb8>
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  &= ~(1 << WAKEUPE);
						break;
					case USB_INT_SUSPI:
						UDIEN  &= ~(1 << SUSPE);
     80e:	80 91 e2 00 	lds	r24, 0x00E2	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
     812:	8e 7f       	andi	r24, 0xFE	; 254
     814:	80 93 e2 00 	sts	0x00E2, r24	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
						USBCON |= (1 << IDTE);
						break;
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  |= (1 << WAKEUPE);
     818:	80 91 e2 00 	lds	r24, 0x00E2	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
     81c:	80 61       	ori	r24, 0x10	; 16
     81e:	80 93 e2 00 	sts	0x00E2, r24	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
			#endif

			static inline void USB_CLK_Freeze(void) ATTR_ALWAYS_INLINE;
			static inline void USB_CLK_Freeze(void)
			{
				USBCON |=  (1 << FRZCLK);
     822:	80 91 d8 00 	lds	r24, 0x00D8	; 0x8000d8 <__TEXT_REGION_LENGTH__+0x7e00d8>
     826:	80 62       	ori	r24, 0x20	; 32
     828:	80 93 d8 00 	sts	0x00D8, r24	; 0x8000d8 <__TEXT_REGION_LENGTH__+0x7e00d8>
			}

			static inline void USB_PLL_Off(void) ATTR_ALWAYS_INLINE;
			static inline void USB_PLL_Off(void)
			{
				PLLCSR = 0;
     82c:	19 bc       	out	0x29, r1	; 41

		#if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
		USB_DeviceState = DEVICE_STATE_Unattached;
		EVENT_USB_Device_Disconnect();
		#else
		USB_DeviceState = DEVICE_STATE_Suspended;
     82e:	85 e0       	ldi	r24, 0x05	; 5
     830:	80 93 18 01 	sts	0x0118, r24	; 0x800118 <USB_DeviceState>
		EVENT_USB_Device_Suspend();
     834:	cb d1       	rcall	.+918    	; 0xbcc <USB_Event_Stub>
					case USB_INT_IDTI:
						return (USBINT & (1 << IDTI));
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						return (UDINT  & (1 << WAKEUPI));
     836:	80 91 e1 00 	lds	r24, 0x00E1	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
		#endif
	}

	if (USB_INT_HasOccurred(USB_INT_WAKEUPI) && USB_INT_IsEnabled(USB_INT_WAKEUPI))
     83a:	84 ff       	sbrs	r24, 4
     83c:	2f c0       	rjmp	.+94     	; 0x89c <__vector_10+0x11e>
					case USB_INT_IDTI:
						return (USBCON & (1 << IDTE));
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						return (UDIEN  & (1 << WAKEUPE));
     83e:	80 91 e2 00 	lds	r24, 0x00E2	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
     842:	84 ff       	sbrs	r24, 4
     844:	2b c0       	rjmp	.+86     	; 0x89c <__vector_10+0x11e>

		/* Inline Functions: */
			static inline void USB_PLL_On(void) ATTR_ALWAYS_INLINE;
			static inline void USB_PLL_On(void)
			{
				PLLCSR = USB_PLL_PSC;
     846:	80 e1       	ldi	r24, 0x10	; 16
     848:	89 bd       	out	0x29, r24	; 41
				PLLCSR = (USB_PLL_PSC | (1 << PLLE));
     84a:	82 e1       	ldi	r24, 0x12	; 18
     84c:	89 bd       	out	0x29, r24	; 41
	{
		if (!(USB_Options & USB_OPT_MANUAL_PLL))
		{
			USB_PLL_On();
			while (!(USB_PLL_IsReady()));
     84e:	09 b4       	in	r0, 0x29	; 41
     850:	00 fe       	sbrs	r0, 0
     852:	fd cf       	rjmp	.-6      	; 0x84e <__vector_10+0xd0>
			}

			static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE;
			static inline void USB_CLK_Unfreeze(void)
			{
				USBCON &= ~(1 << FRZCLK);
     854:	80 91 d8 00 	lds	r24, 0x00D8	; 0x8000d8 <__TEXT_REGION_LENGTH__+0x7e00d8>
     858:	8f 7d       	andi	r24, 0xDF	; 223
     85a:	80 93 d8 00 	sts	0x00D8, r24	; 0x8000d8 <__TEXT_REGION_LENGTH__+0x7e00d8>
						USBINT &= ~(1 << IDTI);
						break;
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDINT  &= ~(1 << WAKEUPI);
     85e:	80 91 e1 00 	lds	r24, 0x00E1	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
     862:	8f 7e       	andi	r24, 0xEF	; 239
     864:	80 93 e1 00 	sts	0x00E1, r24	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
						USBCON &= ~(1 << IDTE);
						break;
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  &= ~(1 << WAKEUPE);
     868:	80 91 e2 00 	lds	r24, 0x00E2	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
     86c:	8f 7e       	andi	r24, 0xEF	; 239
     86e:	80 93 e2 00 	sts	0x00E2, r24	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  |= (1 << WAKEUPE);
						break;
					case USB_INT_SUSPI:
						UDIEN  |= (1 << SUSPE);
     872:	80 91 e2 00 	lds	r24, 0x00E2	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
     876:	81 60       	ori	r24, 0x01	; 1
     878:	80 93 e2 00 	sts	0x00E2, r24	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
		USB_INT_Clear(USB_INT_WAKEUPI);

		USB_INT_Disable(USB_INT_WAKEUPI);
		USB_INT_Enable(USB_INT_SUSPI);

		if (USB_Device_ConfigurationNumber)
     87c:	80 91 14 01 	lds	r24, 0x0114	; 0x800114 <USB_Device_ConfigurationNumber>
     880:	88 23       	and	r24, r24
     882:	11 f0       	breq	.+4      	; 0x888 <__vector_10+0x10a>
		  USB_DeviceState = DEVICE_STATE_Configured;
     884:	84 e0       	ldi	r24, 0x04	; 4
     886:	07 c0       	rjmp	.+14     	; 0x896 <__vector_10+0x118>
			}

			static inline bool USB_Device_IsAddressSet(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
			static inline bool USB_Device_IsAddressSet(void)
			{
				return (UDADDR & (1 << ADDEN));
     888:	80 91 e3 00 	lds	r24, 0x00E3	; 0x8000e3 <__TEXT_REGION_LENGTH__+0x7e00e3>
		else
		  USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Addressed : DEVICE_STATE_Powered;
     88c:	87 fd       	sbrc	r24, 7
     88e:	02 c0       	rjmp	.+4      	; 0x894 <__vector_10+0x116>
     890:	81 e0       	ldi	r24, 0x01	; 1
     892:	01 c0       	rjmp	.+2      	; 0x896 <__vector_10+0x118>
     894:	83 e0       	ldi	r24, 0x03	; 3
     896:	80 93 18 01 	sts	0x0118, r24	; 0x800118 <USB_DeviceState>

		#if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
		EVENT_USB_Device_Connect();
		#else
		EVENT_USB_Device_WakeUp();
     89a:	98 d1       	rcall	.+816    	; 0xbcc <USB_Event_Stub>
					case USB_INT_WAKEUPI:
						return (UDINT  & (1 << WAKEUPI));
					case USB_INT_SUSPI:
						return (UDINT  & (1 << SUSPI));
					case USB_INT_EORSTI:
						return (UDINT  & (1 << EORSTI));
     89c:	80 91 e1 00 	lds	r24, 0x00E1	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
		#endif
	}

	if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI))
     8a0:	83 ff       	sbrs	r24, 3
     8a2:	22 c0       	rjmp	.+68     	; 0x8e8 <__vector_10+0x16a>
					case USB_INT_WAKEUPI:
						return (UDIEN  & (1 << WAKEUPE));
					case USB_INT_SUSPI:
						return (UDIEN  & (1 << SUSPE));
					case USB_INT_EORSTI:
						return (UDIEN  & (1 << EORSTE));
     8a4:	80 91 e2 00 	lds	r24, 0x00E2	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
     8a8:	83 ff       	sbrs	r24, 3
     8aa:	1e c0       	rjmp	.+60     	; 0x8e8 <__vector_10+0x16a>
						break;
					case USB_INT_SUSPI:
						UDINT  &= ~(1 << SUSPI);
						break;
					case USB_INT_EORSTI:
						UDINT  &= ~(1 << EORSTI);
     8ac:	80 91 e1 00 	lds	r24, 0x00E1	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
     8b0:	87 7f       	andi	r24, 0xF7	; 247
     8b2:	80 93 e1 00 	sts	0x00E1, r24	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
	{
		USB_INT_Clear(USB_INT_EORSTI);

		USB_DeviceState                = DEVICE_STATE_Default;
     8b6:	82 e0       	ldi	r24, 0x02	; 2
     8b8:	80 93 18 01 	sts	0x0118, r24	; 0x800118 <USB_DeviceState>
		USB_Device_ConfigurationNumber = 0;
     8bc:	10 92 14 01 	sts	0x0114, r1	; 0x800114 <USB_Device_ConfigurationNumber>
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDINT  &= ~(1 << WAKEUPI);
						break;
					case USB_INT_SUSPI:
						UDINT  &= ~(1 << SUSPI);
     8c0:	80 91 e1 00 	lds	r24, 0x00E1	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
     8c4:	8e 7f       	andi	r24, 0xFE	; 254
     8c6:	80 93 e1 00 	sts	0x00E1, r24	; 0x8000e1 <__TEXT_REGION_LENGTH__+0x7e00e1>
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  &= ~(1 << WAKEUPE);
						break;
					case USB_INT_SUSPI:
						UDIEN  &= ~(1 << SUSPE);
     8ca:	80 91 e2 00 	lds	r24, 0x00E2	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
     8ce:	8e 7f       	andi	r24, 0xFE	; 254
     8d0:	80 93 e2 00 	sts	0x00E2, r24	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
						USBCON |= (1 << IDTE);
						break;
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  |= (1 << WAKEUPE);
     8d4:	80 91 e2 00 	lds	r24, 0x00E2	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
     8d8:	80 61       	ori	r24, 0x10	; 16
     8da:	80 93 e2 00 	sts	0x00E2, r24	; 0x8000e2 <__TEXT_REGION_LENGTH__+0x7e00e2>
				uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);

				if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
				  return false;

				return Endpoint_ConfigureEndpoint_Prv(Number,
     8de:	42 e0       	ldi	r20, 0x02	; 2
     8e0:	60 e0       	ldi	r22, 0x00	; 0
     8e2:	80 e0       	ldi	r24, 0x00	; 0
     8e4:	2b de       	rcall	.-938    	; 0x53c <Endpoint_ConfigureEndpoint_Prv>

		#if defined(INTERRUPT_CONTROL_ENDPOINT)
		USB_INT_Enable(USB_INT_RXSTPI);
		#endif

		EVENT_USB_Device_Reset();
     8e6:	72 d1       	rcall	.+740    	; 0xbcc <USB_Event_Stub>
     8e8:	ff 91       	pop	r31
		USB_ResetInterface();

		EVENT_USB_UIDChange();
	}
	#endif
}
     8ea:	ef 91       	pop	r30
     8ec:	bf 91       	pop	r27
     8ee:	af 91       	pop	r26
     8f0:	9f 91       	pop	r25
     8f2:	8f 91       	pop	r24
     8f4:	7f 91       	pop	r23
     8f6:	6f 91       	pop	r22
     8f8:	5f 91       	pop	r21
     8fa:	4f 91       	pop	r20
     8fc:	3f 91       	pop	r19
     8fe:	2f 91       	pop	r18
     900:	0f 90       	pop	r0
     902:	0f be       	out	0x3f, r0	; 63
     904:	0f 90       	pop	r0
     906:	1f 90       	pop	r1
     908:	18 95       	reti

0000090a <USB_Device_ProcessControlRequest>:
     90a:	1f 93       	push	r17
#if !defined(NO_DEVICE_REMOTE_WAKEUP)
bool    USB_Device_RemoteWakeupEnabled;
#endif

void USB_Device_ProcessControlRequest(void)
{
     90c:	cf 93       	push	r28
     90e:	df 93       	push	r29
     910:	cd b7       	in	r28, 0x3d	; 61
     912:	de b7       	in	r29, 0x3e	; 62
     914:	aa 97       	sbiw	r28, 0x2a	; 42
     916:	0f b6       	in	r0, 0x3f	; 63
     918:	f8 94       	cli
     91a:	de bf       	out	0x3e, r29	; 62
     91c:	0f be       	out	0x3f, r0	; 63
     91e:	cd bf       	out	0x3d, r28	; 61
     920:	e9 e1       	ldi	r30, 0x19	; 25
     922:	f1 e0       	ldi	r31, 0x01	; 1
			 *  \return Next byte in the currently selected endpoint's FIFO buffer.
			 */
			static inline uint8_t Endpoint_Read_8(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline uint8_t Endpoint_Read_8(void)
			{
				return UEDATX;
     924:	80 91 f1 00 	lds	r24, 0x00F1	; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1>
	USB_ControlRequest.wLength       = Endpoint_Read_16_LE();
	#else
	uint8_t* RequestHeader = (uint8_t*)&USB_ControlRequest;

	for (uint8_t RequestHeaderByte = 0; RequestHeaderByte < sizeof(USB_Request_Header_t); RequestHeaderByte++)
	  *(RequestHeader++) = Endpoint_Read_8();
     928:	81 93       	st	Z+, r24
	USB_ControlRequest.wIndex        = Endpoint_Read_16_LE();
	USB_ControlRequest.wLength       = Endpoint_Read_16_LE();
	#else
	uint8_t* RequestHeader = (uint8_t*)&USB_ControlRequest;

	for (uint8_t RequestHeaderByte = 0; RequestHeaderByte < sizeof(USB_Request_Header_t); RequestHeaderByte++)
     92a:	21 e0       	ldi	r18, 0x01	; 1
     92c:	e1 32       	cpi	r30, 0x21	; 33
     92e:	f2 07       	cpc	r31, r18
     930:	c9 f7       	brne	.-14     	; 0x924 <USB_Device_ProcessControlRequest+0x1a>
	  *(RequestHeader++) = Endpoint_Read_8();
	#endif

	EVENT_USB_Device_ControlRequest();
     932:	5f dc       	rcall	.-1858   	; 0x1f2 <EVENT_USB_Device_ControlRequest>
			 *  \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsSETUPReceived(void)
			{
				return ((UEINTX & (1 << RXSTPI)) ? true : false);
     934:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>

	if (Endpoint_IsSETUPReceived())
     938:	83 ff       	sbrs	r24, 3
     93a:	30 c1       	rjmp	.+608    	; 0xb9c <__stack+0x9d>
	{
		uint8_t bmRequestType = USB_ControlRequest.bmRequestType;
     93c:	80 91 19 01 	lds	r24, 0x0119	; 0x800119 <USB_ControlRequest>

		switch (USB_ControlRequest.bRequest)
     940:	90 91 1a 01 	lds	r25, 0x011A	; 0x80011a <USB_ControlRequest+0x1>
     944:	95 30       	cpi	r25, 0x05	; 5
     946:	09 f4       	brne	.+2      	; 0x94a <USB_Device_ProcessControlRequest+0x40>
     948:	83 c0       	rjmp	.+262    	; 0xa50 <USB_Device_ProcessControlRequest+0x146>
     94a:	30 f4       	brcc	.+12     	; 0x958 <USB_Device_ProcessControlRequest+0x4e>
     94c:	91 30       	cpi	r25, 0x01	; 1
     94e:	a9 f1       	breq	.+106    	; 0x9ba <USB_Device_ProcessControlRequest+0xb0>
     950:	68 f0       	brcs	.+26     	; 0x96c <USB_Device_ProcessControlRequest+0x62>
     952:	93 30       	cpi	r25, 0x03	; 3
     954:	91 f1       	breq	.+100    	; 0x9ba <USB_Device_ProcessControlRequest+0xb0>
     956:	22 c1       	rjmp	.+580    	; 0xb9c <__stack+0x9d>
     958:	98 30       	cpi	r25, 0x08	; 8
     95a:	09 f4       	brne	.+2      	; 0x95e <USB_Device_ProcessControlRequest+0x54>
     95c:	ef c0       	rjmp	.+478    	; 0xb3c <__stack+0x3d>
     95e:	99 30       	cpi	r25, 0x09	; 9
     960:	09 f4       	brne	.+2      	; 0x964 <USB_Device_ProcessControlRequest+0x5a>
     962:	fb c0       	rjmp	.+502    	; 0xb5a <__stack+0x5b>
     964:	96 30       	cpi	r25, 0x06	; 6
     966:	09 f0       	breq	.+2      	; 0x96a <USB_Device_ProcessControlRequest+0x60>
     968:	19 c1       	rjmp	.+562    	; 0xb9c <__stack+0x9d>
     96a:	94 c0       	rjmp	.+296    	; 0xa94 <USB_Device_ProcessControlRequest+0x18a>
		{
			case REQ_GetStatus:
				if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
     96c:	80 38       	cpi	r24, 0x80	; 128
     96e:	21 f0       	breq	.+8      	; 0x978 <USB_Device_ProcessControlRequest+0x6e>
     970:	82 38       	cpi	r24, 0x82	; 130
     972:	09 f0       	breq	.+2      	; 0x976 <USB_Device_ProcessControlRequest+0x6c>
     974:	13 c1       	rjmp	.+550    	; 0xb9c <__stack+0x9d>
     976:	08 c0       	rjmp	.+16     	; 0x988 <USB_Device_ProcessControlRequest+0x7e>
	Endpoint_ClearOUT();
}

static void USB_Device_GetStatus(void)
{
	uint8_t CurrentStatus = 0;
     978:	80 91 15 01 	lds	r24, 0x0115	; 0x800115 <USB_Device_CurrentlySelfPowered>
			if (USB_Device_CurrentlySelfPowered)
			  CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
			#endif

			#if !defined(NO_DEVICE_REMOTE_WAKEUP)
			if (USB_Device_RemoteWakeupEnabled)
     97c:	90 91 16 01 	lds	r25, 0x0116	; 0x800116 <USB_Device_RemoteWakeupEnabled>
     980:	99 23       	and	r25, r25
     982:	89 f0       	breq	.+34     	; 0x9a6 <USB_Device_ProcessControlRequest+0x9c>
			  CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
     984:	82 60       	ori	r24, 0x02	; 2
     986:	0f c0       	rjmp	.+30     	; 0x9a6 <USB_Device_ProcessControlRequest+0x9c>
			break;
		}
		case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
		{
			#if !defined(CONTROL_ONLY_DEVICE)
			uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
     988:	80 91 1d 01 	lds	r24, 0x011D	; 0x80011d <USB_ControlRequest+0x4>
     98c:	8f 70       	andi	r24, 0x0F	; 15

			if (EndpointIndex >= ENDPOINT_TOTAL_ENDPOINTS)
     98e:	87 30       	cpi	r24, 0x07	; 7
     990:	08 f0       	brcs	.+2      	; 0x994 <USB_Device_ProcessControlRequest+0x8a>
     992:	04 c1       	rjmp	.+520    	; 0xb9c <__stack+0x9d>
			 */
			static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_SelectEndpoint(const uint8_t Address)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UENUM = (Address & ENDPOINT_EPNUM_MASK);
     994:	80 93 e9 00 	sts	0x00E9, r24	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>
			 *  \return Boolean \c true if the currently selected endpoint is stalled, \c false otherwise.
			 */
			static inline bool Endpoint_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsStalled(void)
			{
				return ((UECONX & (1 << STALLRQ)) ? true : false);
     998:	80 91 eb 00 	lds	r24, 0x00EB	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
				return;

			Endpoint_SelectEndpoint(EndpointIndex);

			CurrentStatus = Endpoint_IsStalled();
     99c:	85 fb       	bst	r24, 5
     99e:	88 27       	eor	r24, r24
     9a0:	80 f9       	bld	r24, 0
			 */
			static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_SelectEndpoint(const uint8_t Address)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UENUM = (Address & ENDPOINT_EPNUM_MASK);
     9a2:	10 92 e9 00 	sts	0x00E9, r1	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>
			 *  \note This is not applicable for non CONTROL type endpoints.
			 */
			static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearSETUP(void)
			{
				UEINTX &= ~(1 << RXSTPI);
     9a6:	90 91 e8 00 	lds	r25, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     9aa:	97 7f       	andi	r25, 0xF7	; 247
     9ac:	90 93 e8 00 	sts	0x00E8, r25	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
			 *  \param[in] Data  Data to write to the currently selected endpoint's FIFO buffer.
			 */
			static inline void Endpoint_Write_16_LE(const uint16_t Data) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_Write_16_LE(const uint16_t Data)
			{
				UEDATX = (Data & 0xFF);
     9b0:	80 93 f1 00 	sts	0x00F1, r24	; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1>
				UEDATX = (Data >> 8);
     9b4:	10 92 f1 00 	sts	0x00F1, r1	; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1>
     9b8:	cc c0       	rjmp	.+408    	; 0xb52 <__stack+0x53>
				}

				break;
			case REQ_ClearFeature:
			case REQ_SetFeature:
				if ((bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE)) ||
     9ba:	28 2f       	mov	r18, r24
     9bc:	2d 7f       	andi	r18, 0xFD	; 253
     9be:	09 f0       	breq	.+2      	; 0x9c2 <USB_Device_ProcessControlRequest+0xb8>
     9c0:	ed c0       	rjmp	.+474    	; 0xb9c <__stack+0x9d>
	Endpoint_ClearStatusStage();
}

static void USB_Device_ClearSetFeature(void)
{
	switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
     9c2:	88 23       	and	r24, r24
     9c4:	19 f0       	breq	.+6      	; 0x9cc <USB_Device_ProcessControlRequest+0xc2>
     9c6:	82 30       	cpi	r24, 0x02	; 2
     9c8:	61 f0       	breq	.+24     	; 0x9e2 <USB_Device_ProcessControlRequest+0xd8>
     9ca:	e8 c0       	rjmp	.+464    	; 0xb9c <__stack+0x9d>
	{
		#if !defined(NO_DEVICE_REMOTE_WAKEUP)
		case REQREC_DEVICE:
		{
			if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_DeviceRemoteWakeup)
     9cc:	80 91 1b 01 	lds	r24, 0x011B	; 0x80011b <USB_ControlRequest+0x2>
     9d0:	81 30       	cpi	r24, 0x01	; 1
     9d2:	09 f0       	breq	.+2      	; 0x9d6 <USB_Device_ProcessControlRequest+0xcc>
     9d4:	e3 c0       	rjmp	.+454    	; 0xb9c <__stack+0x9d>
			  USB_Device_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
     9d6:	93 30       	cpi	r25, 0x03	; 3
     9d8:	09 f0       	breq	.+2      	; 0x9dc <USB_Device_ProcessControlRequest+0xd2>
     9da:	80 e0       	ldi	r24, 0x00	; 0
     9dc:	80 93 16 01 	sts	0x0116, r24	; 0x800116 <USB_Device_RemoteWakeupEnabled>
     9e0:	2e c0       	rjmp	.+92     	; 0xa3e <USB_Device_ProcessControlRequest+0x134>
		}
		#endif
		#if !defined(CONTROL_ONLY_DEVICE)
		case REQREC_ENDPOINT:
		{
			if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_EndpointHalt)
     9e2:	80 91 1b 01 	lds	r24, 0x011B	; 0x80011b <USB_ControlRequest+0x2>
     9e6:	81 11       	cpse	r24, r1
     9e8:	2a c0       	rjmp	.+84     	; 0xa3e <USB_Device_ProcessControlRequest+0x134>
			{
				uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
     9ea:	80 91 1d 01 	lds	r24, 0x011D	; 0x80011d <USB_ControlRequest+0x4>
     9ee:	8f 70       	andi	r24, 0x0F	; 15

				if (EndpointIndex == ENDPOINT_CONTROLEP || EndpointIndex >= ENDPOINT_TOTAL_ENDPOINTS)
     9f0:	2f ef       	ldi	r18, 0xFF	; 255
     9f2:	28 0f       	add	r18, r24
     9f4:	26 30       	cpi	r18, 0x06	; 6
     9f6:	08 f0       	brcs	.+2      	; 0x9fa <USB_Device_ProcessControlRequest+0xf0>
     9f8:	d1 c0       	rjmp	.+418    	; 0xb9c <__stack+0x9d>
			 */
			static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_SelectEndpoint(const uint8_t Address)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UENUM = (Address & ENDPOINT_EPNUM_MASK);
     9fa:	80 93 e9 00 	sts	0x00E9, r24	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>
			 * \return Boolean \c true if the currently selected endpoint is enabled, \c false otherwise.
			 */
			static inline bool Endpoint_IsEnabled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsEnabled(void)
			{
				return ((UECONX & (1 << EPEN)) ? true : false);
     9fe:	20 91 eb 00 	lds	r18, 0x00EB	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
				  return;

				Endpoint_SelectEndpoint(EndpointIndex);

				if (Endpoint_IsEnabled())
     a02:	20 ff       	sbrs	r18, 0
     a04:	1c c0       	rjmp	.+56     	; 0xa3e <USB_Device_ProcessControlRequest+0x134>
				{
					if (USB_ControlRequest.bRequest == REQ_SetFeature)
     a06:	93 30       	cpi	r25, 0x03	; 3
     a08:	21 f4       	brne	.+8      	; 0xa12 <USB_Device_ProcessControlRequest+0x108>
			 *  \ingroup Group_EndpointPacketManagement_AVR8
			 */
			static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_StallTransaction(void)
			{
				UECONX |= (1 << STALLRQ);
     a0a:	80 91 eb 00 	lds	r24, 0x00EB	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
     a0e:	80 62       	ori	r24, 0x20	; 32
     a10:	14 c0       	rjmp	.+40     	; 0xa3a <USB_Device_ProcessControlRequest+0x130>
			 *  \ingroup Group_EndpointPacketManagement_AVR8
			 */
			static inline void Endpoint_ClearStall(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearStall(void)
			{
				UECONX |= (1 << STALLRQC);
     a12:	90 91 eb 00 	lds	r25, 0x00EB	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
     a16:	90 61       	ori	r25, 0x10	; 16
     a18:	90 93 eb 00 	sts	0x00EB, r25	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
			 *  \param[in] Address  Endpoint address whose FIFO buffers are to be reset.
			 */
			static inline void Endpoint_ResetEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ResetEndpoint(const uint8_t Address)
			{
				UERST = (1 << (Address & ENDPOINT_EPNUM_MASK));
     a1c:	21 e0       	ldi	r18, 0x01	; 1
     a1e:	30 e0       	ldi	r19, 0x00	; 0
     a20:	a9 01       	movw	r20, r18
     a22:	02 c0       	rjmp	.+4      	; 0xa28 <USB_Device_ProcessControlRequest+0x11e>
     a24:	44 0f       	add	r20, r20
     a26:	55 1f       	adc	r21, r21
     a28:	8a 95       	dec	r24
     a2a:	e2 f7       	brpl	.-8      	; 0xa24 <USB_Device_ProcessControlRequest+0x11a>
     a2c:	40 93 ea 00 	sts	0x00EA, r20	; 0x8000ea <__TEXT_REGION_LENGTH__+0x7e00ea>
				UERST = 0;
     a30:	10 92 ea 00 	sts	0x00EA, r1	; 0x8000ea <__TEXT_REGION_LENGTH__+0x7e00ea>

			/** Resets the data toggle of the currently selected endpoint. */
			static inline void Endpoint_ResetDataToggle(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ResetDataToggle(void)
			{
				UECONX |= (1 << RSTDT);
     a34:	80 91 eb 00 	lds	r24, 0x00EB	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
     a38:	88 60       	ori	r24, 0x08	; 8
     a3a:	80 93 eb 00 	sts	0x00EB, r24	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
			 */
			static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_SelectEndpoint(const uint8_t Address)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UENUM = (Address & ENDPOINT_EPNUM_MASK);
     a3e:	10 92 e9 00 	sts	0x00E9, r1	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>
			 *  \note This is not applicable for non CONTROL type endpoints.
			 */
			static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearSETUP(void)
			{
				UEINTX &= ~(1 << RXSTPI);
     a42:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     a46:	87 7f       	andi	r24, 0xF7	; 247
     a48:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>

	Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);

	Endpoint_ClearSETUP();

	Endpoint_ClearStatusStage();
     a4c:	e9 dd       	rcall	.-1070   	; 0x620 <Endpoint_ClearStatusStage>
     a4e:	a6 c0       	rjmp	.+332    	; 0xb9c <__stack+0x9d>
					USB_Device_ClearSetFeature();
				}

				break;
			case REQ_SetAddress:
				if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
     a50:	81 11       	cpse	r24, r1
     a52:	a4 c0       	rjmp	.+328    	; 0xb9c <__stack+0x9d>
	}
}

static void USB_Device_SetAddress(void)
{
	uint8_t DeviceAddress = (USB_ControlRequest.wValue & 0x7F);
     a54:	10 91 1b 01 	lds	r17, 0x011B	; 0x80011b <USB_ControlRequest+0x2>
     a58:	1f 77       	andi	r17, 0x7F	; 127
			#endif

			static inline void USB_Device_SetDeviceAddress(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void USB_Device_SetDeviceAddress(const uint8_t Address)
			{
				UDADDR = (UDADDR & (1 << ADDEN)) | (Address & 0x7F);
     a5a:	80 91 e3 00 	lds	r24, 0x00E3	; 0x8000e3 <__TEXT_REGION_LENGTH__+0x7e00e3>
     a5e:	80 78       	andi	r24, 0x80	; 128
     a60:	81 2b       	or	r24, r17
     a62:	80 93 e3 00 	sts	0x00E3, r24	; 0x8000e3 <__TEXT_REGION_LENGTH__+0x7e00e3>
     a66:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     a6a:	87 7f       	andi	r24, 0xF7	; 247
     a6c:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>

	USB_Device_SetDeviceAddress(DeviceAddress);

	Endpoint_ClearSETUP();

	Endpoint_ClearStatusStage();
     a70:	d7 dd       	rcall	.-1106   	; 0x620 <Endpoint_ClearStatusStage>
			 *  \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsINReady(void)
			{
				return ((UEINTX & (1 << TXINI)) ? true : false);
     a72:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>

	while (!(Endpoint_IsINReady()));
     a76:	80 ff       	sbrs	r24, 0
     a78:	fc cf       	rjmp	.-8      	; 0xa72 <USB_Device_ProcessControlRequest+0x168>
			static inline void USB_Device_EnableDeviceAddress(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void USB_Device_EnableDeviceAddress(const uint8_t Address)
			{
				(void)Address;

				UDADDR |= (1 << ADDEN);
     a7a:	80 91 e3 00 	lds	r24, 0x00E3	; 0x8000e3 <__TEXT_REGION_LENGTH__+0x7e00e3>
     a7e:	80 68       	ori	r24, 0x80	; 128
     a80:	80 93 e3 00 	sts	0x00E3, r24	; 0x8000e3 <__TEXT_REGION_LENGTH__+0x7e00e3>

	USB_Device_EnableDeviceAddress(DeviceAddress);

	USB_DeviceState = (DeviceAddress) ? DEVICE_STATE_Addressed : DEVICE_STATE_Default;
     a84:	11 11       	cpse	r17, r1
     a86:	02 c0       	rjmp	.+4      	; 0xa8c <USB_Device_ProcessControlRequest+0x182>
     a88:	82 e0       	ldi	r24, 0x02	; 2
     a8a:	01 c0       	rjmp	.+2      	; 0xa8e <USB_Device_ProcessControlRequest+0x184>
     a8c:	83 e0       	ldi	r24, 0x03	; 3
     a8e:	80 93 18 01 	sts	0x0118, r24	; 0x800118 <USB_DeviceState>
     a92:	84 c0       	rjmp	.+264    	; 0xb9c <__stack+0x9d>
				if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
				  USB_Device_SetAddress();

				break;
			case REQ_GetDescriptor:
				if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
     a94:	80 58       	subi	r24, 0x80	; 128
     a96:	82 30       	cpi	r24, 0x02	; 2
     a98:	08 f0       	brcs	.+2      	; 0xa9c <USB_Device_ProcessControlRequest+0x192>
     a9a:	80 c0       	rjmp	.+256    	; 0xb9c <__stack+0x9d>
	    !(defined(USE_FLASH_DESCRIPTORS) || defined(USE_EEPROM_DESCRIPTORS) || defined(USE_RAM_DESCRIPTORS))
	uint8_t DescriptorAddressSpace;
	#endif

	#if !defined(NO_INTERNAL_SERIAL) && (USE_INTERNAL_SERIAL != NO_DESCRIPTOR)
	if (USB_ControlRequest.wValue == ((DTYPE_String << 8) | USE_INTERNAL_SERIAL))
     a9c:	80 91 1b 01 	lds	r24, 0x011B	; 0x80011b <USB_ControlRequest+0x2>
     aa0:	90 91 1c 01 	lds	r25, 0x011C	; 0x80011c <USB_ControlRequest+0x3>
     aa4:	8c 3d       	cpi	r24, 0xDC	; 220
     aa6:	53 e0       	ldi	r21, 0x03	; 3
     aa8:	95 07       	cpc	r25, r21
     aaa:	71 f5       	brne	.+92     	; 0xb08 <__stack+0x9>
	{
		USB_Descriptor_Header_t Header;
		uint16_t                UnicodeString[INTERNAL_SERIAL_LENGTH_BITS / 4];
	} SignatureDescriptor;

	SignatureDescriptor.Header.Type = DTYPE_String;
     aac:	83 e0       	ldi	r24, 0x03	; 3
     aae:	8a 83       	std	Y+2, r24	; 0x02
	SignatureDescriptor.Header.Size = USB_STRING_LEN(INTERNAL_SERIAL_LENGTH_BITS / 4);
     ab0:	8a e2       	ldi	r24, 0x2A	; 42
     ab2:	89 83       	std	Y+1, r24	; 0x01
			static inline uint_reg_t GetGlobalInterruptMask(void)
			{
				GCC_MEMORY_BARRIER();

				#if (ARCH == ARCH_AVR8)
				return SREG;
     ab4:	4f b7       	in	r20, 0x3f	; 63
			static inline void GlobalInterruptDisable(void)
			{
				GCC_MEMORY_BARRIER();

				#if (ARCH == ARCH_AVR8)
				cli();
     ab6:	f8 94       	cli
				__builtin_ssrf(AVR32_SR_GM_OFFSET);
				#elif (ARCH == ARCH_XMEGA)
				cli();
				#endif

				GCC_MEMORY_BARRIER();
     ab8:	de 01       	movw	r26, r28
     aba:	13 96       	adiw	r26, 0x03	; 3
				uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
				GlobalInterruptDisable();

				uint8_t SigReadAddress = INTERNAL_SERIAL_START_ADDRESS;

				for (uint8_t SerialCharNum = 0; SerialCharNum < (INTERNAL_SERIAL_LENGTH_BITS / 4); SerialCharNum++)
     abc:	20 e0       	ldi	r18, 0x00	; 0
			static inline void USB_Device_GetSerialString(uint16_t* const UnicodeString)
			{
				uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
				GlobalInterruptDisable();

				uint8_t SigReadAddress = INTERNAL_SERIAL_START_ADDRESS;
     abe:	3e e0       	ldi	r19, 0x0E	; 14

				for (uint8_t SerialCharNum = 0; SerialCharNum < (INTERNAL_SERIAL_LENGTH_BITS / 4); SerialCharNum++)
				{
					uint8_t SerialByte = boot_signature_byte_get(SigReadAddress);
     ac0:	51 e2       	ldi	r21, 0x21	; 33
     ac2:	e3 2f       	mov	r30, r19
     ac4:	f0 e0       	ldi	r31, 0x00	; 0
     ac6:	50 93 57 00 	sts	0x0057, r21	; 0x800057 <__TEXT_REGION_LENGTH__+0x7e0057>
     aca:	e4 91       	lpm	r30, Z

					if (SerialCharNum & 0x01)
     acc:	20 ff       	sbrs	r18, 0
     ace:	03 c0       	rjmp	.+6      	; 0xad6 <USB_Device_ProcessControlRequest+0x1cc>
					{
						SerialByte >>= 4;
     ad0:	e2 95       	swap	r30
     ad2:	ef 70       	andi	r30, 0x0F	; 15
						SigReadAddress++;
     ad4:	3f 5f       	subi	r19, 0xFF	; 255
					}

					SerialByte &= 0x0F;
     ad6:	ef 70       	andi	r30, 0x0F	; 15
     ad8:	8e 2f       	mov	r24, r30
     ada:	90 e0       	ldi	r25, 0x00	; 0

					UnicodeString[SerialCharNum] = cpu_to_le16((SerialByte >= 10) ?
     adc:	ea 30       	cpi	r30, 0x0A	; 10
     ade:	10 f0       	brcs	.+4      	; 0xae4 <USB_Device_ProcessControlRequest+0x1da>
     ae0:	c7 96       	adiw	r24, 0x37	; 55
     ae2:	01 c0       	rjmp	.+2      	; 0xae6 <USB_Device_ProcessControlRequest+0x1dc>
     ae4:	c0 96       	adiw	r24, 0x30	; 48
     ae6:	8d 93       	st	X+, r24
     ae8:	9d 93       	st	X+, r25
				uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
				GlobalInterruptDisable();

				uint8_t SigReadAddress = INTERNAL_SERIAL_START_ADDRESS;

				for (uint8_t SerialCharNum = 0; SerialCharNum < (INTERNAL_SERIAL_LENGTH_BITS / 4); SerialCharNum++)
     aea:	2f 5f       	subi	r18, 0xFF	; 255
     aec:	24 31       	cpi	r18, 0x14	; 20
     aee:	49 f7       	brne	.-46     	; 0xac2 <USB_Device_ProcessControlRequest+0x1b8>
			static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
			{
				GCC_MEMORY_BARRIER();

				#if (ARCH == ARCH_AVR8)
				SREG = GlobalIntState;
     af0:	4f bf       	out	0x3f, r20	; 63
			 *  \note This is not applicable for non CONTROL type endpoints.
			 */
			static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearSETUP(void)
			{
				UEINTX &= ~(1 << RXSTPI);
     af2:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     af6:	87 7f       	andi	r24, 0xF7	; 247
     af8:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>

	USB_Device_GetSerialString(SignatureDescriptor.UnicodeString);

	Endpoint_ClearSETUP();

	Endpoint_Write_Control_Stream_LE(&SignatureDescriptor, sizeof(SignatureDescriptor));
     afc:	6a e2       	ldi	r22, 0x2A	; 42
     afe:	70 e0       	ldi	r23, 0x00	; 0
     b00:	ce 01       	movw	r24, r28
     b02:	01 96       	adiw	r24, 0x01	; 1
     b04:	1c dc       	rcall	.-1992   	; 0x33e <Endpoint_Write_Control_Stream_LE>
     b06:	14 c0       	rjmp	.+40     	; 0xb30 <__stack+0x31>
		USB_Device_GetInternalSerialDescriptor();
		return;
	}
	#endif

	if ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex,
     b08:	60 91 1d 01 	lds	r22, 0x011D	; 0x80011d <USB_ControlRequest+0x4>
     b0c:	70 91 1e 01 	lds	r23, 0x011E	; 0x80011e <USB_ControlRequest+0x5>
     b10:	ae 01       	movw	r20, r28
     b12:	4f 5f       	subi	r20, 0xFF	; 255
     b14:	5f 4f       	sbci	r21, 0xFF	; 255
     b16:	88 db       	rcall	.-2288   	; 0x228 <CALLBACK_USB_GetDescriptor>
     b18:	bc 01       	movw	r22, r24
     b1a:	89 2b       	or	r24, r25
     b1c:	09 f4       	brne	.+2      	; 0xb20 <__stack+0x21>
     b1e:	3e c0       	rjmp	.+124    	; 0xb9c <__stack+0x9d>
     b20:	90 91 e8 00 	lds	r25, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     b24:	97 7f       	andi	r25, 0xF7	; 247
     b26:	90 93 e8 00 	sts	0x00E8, r25	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
	#if defined(USE_RAM_DESCRIPTORS) || !defined(ARCH_HAS_MULTI_ADDRESS_SPACE)
	Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);
	#elif defined(USE_EEPROM_DESCRIPTORS)
	Endpoint_Write_Control_EStream_LE(DescriptorPointer, DescriptorSize);
	#elif defined(USE_FLASH_DESCRIPTORS)
	Endpoint_Write_Control_PStream_LE(DescriptorPointer, DescriptorSize);
     b2a:	89 81       	ldd	r24, Y+1	; 0x01
     b2c:	9a 81       	ldd	r25, Y+2	; 0x02
     b2e:	a5 dc       	rcall	.-1718   	; 0x47a <Endpoint_Write_Control_PStream_LE>
			 */
			static inline void Endpoint_ClearOUT(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearOUT(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UEINTX &= ~((1 << RXOUTI) | (1 << FIFOCON));
     b30:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     b34:	8b 77       	andi	r24, 0x7B	; 123
     b36:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     b3a:	30 c0       	rjmp	.+96     	; 0xb9c <__stack+0x9d>
					USB_Device_GetDescriptor();
				}

				break;
			case REQ_GetConfiguration:
				if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
     b3c:	80 38       	cpi	r24, 0x80	; 128
     b3e:	71 f5       	brne	.+92     	; 0xb9c <__stack+0x9d>
			 *  \note This is not applicable for non CONTROL type endpoints.
			 */
			static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearSETUP(void)
			{
				UEINTX &= ~(1 << RXSTPI);
     b40:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     b44:	87 7f       	andi	r24, 0xF7	; 247
     b46:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>

static void USB_Device_GetConfiguration(void)
{
	Endpoint_ClearSETUP();

	Endpoint_Write_8(USB_Device_ConfigurationNumber);
     b4a:	80 91 14 01 	lds	r24, 0x0114	; 0x800114 <USB_Device_ConfigurationNumber>
			 *  \param[in] Data  Data to write into the the currently selected endpoint's FIFO buffer.
			 */
			static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_Write_8(const uint8_t Data)
			{
				UEDATX = Data;
     b4e:	80 93 f1 00 	sts	0x00F1, r24	; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1>
			 */
			static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearIN(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
     b52:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     b56:	8e 77       	andi	r24, 0x7E	; 126
     b58:	77 cf       	rjmp	.-274    	; 0xa48 <USB_Device_ProcessControlRequest+0x13e>
				if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
				  USB_Device_GetConfiguration();

				break;
			case REQ_SetConfiguration:
				if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
     b5a:	81 11       	cpse	r24, r1
     b5c:	1f c0       	rjmp	.+62     	; 0xb9c <__stack+0x9d>
}

static void USB_Device_SetConfiguration(void)
{
	#if defined(FIXED_NUM_CONFIGURATIONS)
	if ((uint8_t)USB_ControlRequest.wValue > FIXED_NUM_CONFIGURATIONS)
     b5e:	80 91 1b 01 	lds	r24, 0x011B	; 0x80011b <USB_ControlRequest+0x2>
     b62:	90 91 1c 01 	lds	r25, 0x011C	; 0x80011c <USB_ControlRequest+0x3>
     b66:	99 27       	eor	r25, r25
     b68:	02 97       	sbiw	r24, 0x02	; 2
     b6a:	c4 f4       	brge	.+48     	; 0xb9c <__stack+0x9d>
			 *  \note This is not applicable for non CONTROL type endpoints.
			 */
			static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearSETUP(void)
			{
				UEINTX &= ~(1 << RXSTPI);
     b6c:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     b70:	87 7f       	andi	r24, 0xF7	; 247
     b72:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
	#endif
	#endif

	Endpoint_ClearSETUP();

	USB_Device_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
     b76:	80 91 1b 01 	lds	r24, 0x011B	; 0x80011b <USB_ControlRequest+0x2>
     b7a:	80 93 14 01 	sts	0x0114, r24	; 0x800114 <USB_Device_ConfigurationNumber>

	Endpoint_ClearStatusStage();
     b7e:	50 dd       	rcall	.-1376   	; 0x620 <Endpoint_ClearStatusStage>

	if (USB_Device_ConfigurationNumber)
     b80:	80 91 14 01 	lds	r24, 0x0114	; 0x800114 <USB_Device_ConfigurationNumber>
     b84:	81 11       	cpse	r24, r1
     b86:	06 c0       	rjmp	.+12     	; 0xb94 <__stack+0x95>
			}

			static inline bool USB_Device_IsAddressSet(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
			static inline bool USB_Device_IsAddressSet(void)
			{
				return (UDADDR & (1 << ADDEN));
     b88:	80 91 e3 00 	lds	r24, 0x00E3	; 0x8000e3 <__TEXT_REGION_LENGTH__+0x7e00e3>
	  USB_DeviceState = DEVICE_STATE_Configured;
	else
	  USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered;
     b8c:	87 fd       	sbrc	r24, 7
     b8e:	02 c0       	rjmp	.+4      	; 0xb94 <__stack+0x95>
     b90:	81 e0       	ldi	r24, 0x01	; 1
     b92:	01 c0       	rjmp	.+2      	; 0xb96 <__stack+0x97>
     b94:	84 e0       	ldi	r24, 0x04	; 4
     b96:	80 93 18 01 	sts	0x0118, r24	; 0x800118 <USB_DeviceState>

	EVENT_USB_Device_ConfigurationChanged();
     b9a:	22 db       	rcall	.-2492   	; 0x1e0 <EVENT_USB_Device_ConfigurationChanged>
			 *  \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsSETUPReceived(void)
			{
				return ((UEINTX & (1 << RXSTPI)) ? true : false);
     b9c:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
			default:
				break;
		}
	}

	if (Endpoint_IsSETUPReceived())
     ba0:	83 ff       	sbrs	r24, 3
     ba2:	0a c0       	rjmp	.+20     	; 0xbb8 <__stack+0xb9>
			 *  \note This is not applicable for non CONTROL type endpoints.
			 */
			static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearSETUP(void)
			{
				UEINTX &= ~(1 << RXSTPI);
     ba4:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     ba8:	87 7f       	andi	r24, 0xF7	; 247
     baa:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
			 *  \ingroup Group_EndpointPacketManagement_AVR8
			 */
			static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_StallTransaction(void)
			{
				UECONX |= (1 << STALLRQ);
     bae:	80 91 eb 00 	lds	r24, 0x00EB	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
     bb2:	80 62       	ori	r24, 0x20	; 32
     bb4:	80 93 eb 00 	sts	0x00EB, r24	; 0x8000eb <__TEXT_REGION_LENGTH__+0x7e00eb>
	{
		Endpoint_ClearSETUP();
		Endpoint_StallTransaction();
	}
}
     bb8:	aa 96       	adiw	r28, 0x2a	; 42
     bba:	0f b6       	in	r0, 0x3f	; 63
     bbc:	f8 94       	cli
     bbe:	de bf       	out	0x3e, r29	; 62
     bc0:	0f be       	out	0x3f, r0	; 63
     bc2:	cd bf       	out	0x3d, r28	; 61
     bc4:	df 91       	pop	r29
     bc6:	cf 91       	pop	r28
     bc8:	1f 91       	pop	r17
     bca:	08 95       	ret

00000bcc <USB_Event_Stub>:
#define  __INCLUDE_FROM_EVENTS_C
#define  __INCLUDE_FROM_USB_DRIVER
#include "Events.h"

void USB_Event_Stub(void)
{
     bcc:	08 95       	ret

00000bce <USB_USBTask>:
#if defined(USB_CAN_BE_DEVICE) && !defined(DEVICE_STATE_AS_GPIOR)
volatile uint8_t     USB_DeviceState;
#endif

void USB_USBTask(void)
{
     bce:	cf 93       	push	r28
}

#if defined(USB_CAN_BE_DEVICE)
static void USB_DeviceTask(void)
{
	if (USB_DeviceState == DEVICE_STATE_Unattached)
     bd0:	80 91 18 01 	lds	r24, 0x0118	; 0x800118 <USB_DeviceState>
     bd4:	88 23       	and	r24, r24
     bd6:	99 f0       	breq	.+38     	; 0xbfe <USB_USBTask+0x30>
			 */
			static inline uint8_t Endpoint_GetCurrentEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline uint8_t Endpoint_GetCurrentEndpoint(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					return ((UENUM & ENDPOINT_EPNUM_MASK) | Endpoint_GetEndpointDirection());
     bd8:	c0 91 e9 00 	lds	r28, 0x00E9	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>
     bdc:	cf 70       	andi	r28, 0x0F	; 15
			 *  \return The currently selected endpoint's direction, as a \c ENDPOINT_DIR_* mask.
			 */
			static inline uint8_t Endpoint_GetEndpointDirection(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline uint8_t Endpoint_GetEndpointDirection(void)
			{
				return (UECFG0X & (1 << EPDIR)) ? ENDPOINT_DIR_IN : ENDPOINT_DIR_OUT;
     bde:	90 91 ec 00 	lds	r25, 0x00EC	; 0x8000ec <__TEXT_REGION_LENGTH__+0x7e00ec>
     be2:	89 2f       	mov	r24, r25
     be4:	81 70       	andi	r24, 0x01	; 1
     be6:	90 fd       	sbrc	r25, 0
     be8:	80 e8       	ldi	r24, 0x80	; 128
			 */
			static inline uint8_t Endpoint_GetCurrentEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline uint8_t Endpoint_GetCurrentEndpoint(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					return ((UENUM & ENDPOINT_EPNUM_MASK) | Endpoint_GetEndpointDirection());
     bea:	c8 2b       	or	r28, r24
			 */
			static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_SelectEndpoint(const uint8_t Address)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UENUM = (Address & ENDPOINT_EPNUM_MASK);
     bec:	10 92 e9 00 	sts	0x00E9, r1	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>
			 *  \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsSETUPReceived(void)
			{
				return ((UEINTX & (1 << RXSTPI)) ? true : false);
     bf0:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>

	uint8_t PrevEndpoint = Endpoint_GetCurrentEndpoint();

	Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);

	if (Endpoint_IsSETUPReceived())
     bf4:	83 fd       	sbrc	r24, 3
	  USB_Device_ProcessControlRequest();
     bf6:	89 de       	rcall	.-750    	; 0x90a <USB_Device_ProcessControlRequest>
			 */
			static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_SelectEndpoint(const uint8_t Address)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UENUM = (Address & ENDPOINT_EPNUM_MASK);
     bf8:	cf 70       	andi	r28, 0x0F	; 15
     bfa:	c0 93 e9 00 	sts	0x00E9, r28	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>
	#elif defined(USB_CAN_BE_HOST)
		USB_HostTask();
	#elif defined(USB_CAN_BE_DEVICE)
		USB_DeviceTask();
	#endif
}
     bfe:	cf 91       	pop	r28
     c00:	08 95       	ret

00000c02 <HID_Device_ProcessControlRequest>:
#define  __INCLUDE_FROM_HID_DRIVER
#define  __INCLUDE_FROM_HID_DEVICE_C
#include "HIDClassDevice.h"

void HID_Device_ProcessControlRequest(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
{
     c02:	6f 92       	push	r6
     c04:	7f 92       	push	r7
     c06:	8f 92       	push	r8
     c08:	9f 92       	push	r9
     c0a:	af 92       	push	r10
     c0c:	bf 92       	push	r11
     c0e:	cf 92       	push	r12
     c10:	df 92       	push	r13
     c12:	ef 92       	push	r14
     c14:	ff 92       	push	r15
     c16:	0f 93       	push	r16
     c18:	1f 93       	push	r17
     c1a:	cf 93       	push	r28
     c1c:	df 93       	push	r29
     c1e:	00 d0       	rcall	.+0      	; 0xc20 <HID_Device_ProcessControlRequest+0x1e>
     c20:	1f 92       	push	r1
     c22:	cd b7       	in	r28, 0x3d	; 61
     c24:	de b7       	in	r29, 0x3e	; 62
     c26:	7c 01       	movw	r14, r24
				Endpoint_ClearStatusStage();
			}

			break;
	}
}
     c28:	ad b6       	in	r10, 0x3d	; 61
     c2a:	be b6       	in	r11, 0x3e	; 62
			 *  \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsSETUPReceived(void)
			{
				return ((UEINTX & (1 << RXSTPI)) ? true : false);
     c2c:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
#define  __INCLUDE_FROM_HID_DEVICE_C
#include "HIDClassDevice.h"

void HID_Device_ProcessControlRequest(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
{
	if (!(Endpoint_IsSETUPReceived()))
     c30:	83 ff       	sbrs	r24, 3
     c32:	03 c1       	rjmp	.+518    	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
	  return;

	if (USB_ControlRequest.wIndex != HIDInterfaceInfo->Config.InterfaceNumber)
     c34:	f7 01       	movw	r30, r14
     c36:	80 81       	ld	r24, Z
     c38:	90 e0       	ldi	r25, 0x00	; 0
     c3a:	20 91 1d 01 	lds	r18, 0x011D	; 0x80011d <USB_ControlRequest+0x4>
     c3e:	30 91 1e 01 	lds	r19, 0x011E	; 0x80011e <USB_ControlRequest+0x5>
     c42:	28 17       	cp	r18, r24
     c44:	39 07       	cpc	r19, r25
     c46:	09 f0       	breq	.+2      	; 0xc4a <HID_Device_ProcessControlRequest+0x48>
     c48:	f8 c0       	rjmp	.+496    	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
	  return;

	switch (USB_ControlRequest.bRequest)
     c4a:	80 91 1a 01 	lds	r24, 0x011A	; 0x80011a <USB_ControlRequest+0x1>
     c4e:	83 30       	cpi	r24, 0x03	; 3
     c50:	09 f4       	brne	.+2      	; 0xc54 <HID_Device_ProcessControlRequest+0x52>
     c52:	9a c0       	rjmp	.+308    	; 0xd88 <HID_Device_ProcessControlRequest+0x186>
     c54:	30 f4       	brcc	.+12     	; 0xc62 <HID_Device_ProcessControlRequest+0x60>
     c56:	81 30       	cpi	r24, 0x01	; 1
     c58:	71 f0       	breq	.+28     	; 0xc76 <HID_Device_ProcessControlRequest+0x74>
     c5a:	82 30       	cpi	r24, 0x02	; 2
     c5c:	09 f4       	brne	.+2      	; 0xc60 <HID_Device_ProcessControlRequest+0x5e>
     c5e:	d1 c0       	rjmp	.+418    	; 0xe02 <HID_Device_ProcessControlRequest+0x200>
     c60:	ec c0       	rjmp	.+472    	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
     c62:	8a 30       	cpi	r24, 0x0A	; 10
     c64:	09 f4       	brne	.+2      	; 0xc68 <HID_Device_ProcessControlRequest+0x66>
     c66:	b5 c0       	rjmp	.+362    	; 0xdd2 <HID_Device_ProcessControlRequest+0x1d0>
     c68:	8b 30       	cpi	r24, 0x0B	; 11
     c6a:	09 f4       	brne	.+2      	; 0xc6e <HID_Device_ProcessControlRequest+0x6c>
     c6c:	9e c0       	rjmp	.+316    	; 0xdaa <HID_Device_ProcessControlRequest+0x1a8>
     c6e:	89 30       	cpi	r24, 0x09	; 9
     c70:	09 f0       	breq	.+2      	; 0xc74 <HID_Device_ProcessControlRequest+0x72>
     c72:	e3 c0       	rjmp	.+454    	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
     c74:	4c c0       	rjmp	.+152    	; 0xd0e <HID_Device_ProcessControlRequest+0x10c>
	{
		case HID_REQ_GetReport:
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
     c76:	80 91 19 01 	lds	r24, 0x0119	; 0x800119 <USB_ControlRequest>
     c7a:	81 3a       	cpi	r24, 0xA1	; 161
     c7c:	09 f0       	breq	.+2      	; 0xc80 <HID_Device_ProcessControlRequest+0x7e>
     c7e:	dd c0       	rjmp	.+442    	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
			{
     c80:	8d b6       	in	r8, 0x3d	; 61
     c82:	9e b6       	in	r9, 0x3e	; 62
				uint16_t ReportSize = 0;
     c84:	1a 82       	std	Y+2, r1	; 0x02
     c86:	19 82       	std	Y+1, r1	; 0x01
				uint8_t  ReportID   = (USB_ControlRequest.wValue & 0xFF);
     c88:	80 91 1b 01 	lds	r24, 0x011B	; 0x80011b <USB_ControlRequest+0x2>
     c8c:	10 91 1c 01 	lds	r17, 0x011C	; 0x80011c <USB_ControlRequest+0x3>
     c90:	8b 83       	std	Y+3, r24	; 0x03
				uint8_t  ReportType = (USB_ControlRequest.wValue >> 8) - 1;
				uint8_t  ReportData[HIDInterfaceInfo->Config.PrevReportINBufferSize];
     c92:	f7 01       	movw	r30, r14
     c94:	80 85       	ldd	r24, Z+8	; 0x08
     c96:	48 2f       	mov	r20, r24
     c98:	50 e0       	ldi	r21, 0x00	; 0
     c9a:	8d b7       	in	r24, 0x3d	; 61
     c9c:	9e b7       	in	r25, 0x3e	; 62
     c9e:	84 1b       	sub	r24, r20
     ca0:	95 0b       	sbc	r25, r21
     ca2:	0f b6       	in	r0, 0x3f	; 63
     ca4:	f8 94       	cli
     ca6:	9e bf       	out	0x3e, r25	; 62
     ca8:	0f be       	out	0x3f, r0	; 63
     caa:	8d bf       	out	0x3d, r24	; 61
     cac:	ed b7       	in	r30, 0x3d	; 61
     cae:	fe b7       	in	r31, 0x3e	; 62
     cb0:	31 96       	adiw	r30, 0x01	; 1
     cb2:	6f 01       	movw	r12, r30

				memset(ReportData, 0, sizeof(ReportData));
     cb4:	60 e0       	ldi	r22, 0x00	; 0
     cb6:	70 e0       	ldi	r23, 0x00	; 0
     cb8:	cf 01       	movw	r24, r30
     cba:	b8 d1       	rcall	.+880    	; 0x102c <memset>

				CALLBACK_HID_Device_CreateHIDReport(HIDInterfaceInfo, &ReportID, ReportType, ReportData, &ReportSize);
     cbc:	4f ef       	ldi	r20, 0xFF	; 255
     cbe:	41 0f       	add	r20, r17
     cc0:	8e 01       	movw	r16, r28
     cc2:	0f 5f       	subi	r16, 0xFF	; 255
     cc4:	1f 4f       	sbci	r17, 0xFF	; 255
     cc6:	96 01       	movw	r18, r12
     cc8:	be 01       	movw	r22, r28
     cca:	6d 5f       	subi	r22, 0xFD	; 253
     ccc:	7f 4f       	sbci	r23, 0xFF	; 255
     cce:	c7 01       	movw	r24, r14
     cd0:	9f da       	rcall	.-2754   	; 0x210 <CALLBACK_HID_Device_CreateHIDReport>

				if (HIDInterfaceInfo->Config.PrevReportINBuffer != NULL)
     cd2:	f7 01       	movw	r30, r14
     cd4:	86 81       	ldd	r24, Z+6	; 0x06
     cd6:	97 81       	ldd	r25, Z+7	; 0x07
     cd8:	00 97       	sbiw	r24, 0x00	; 0
     cda:	21 f0       	breq	.+8      	; 0xce4 <HID_Device_ProcessControlRequest+0xe2>
				{
					memcpy(HIDInterfaceInfo->Config.PrevReportINBuffer, ReportData,
     cdc:	40 85       	ldd	r20, Z+8	; 0x08
     cde:	50 e0       	ldi	r21, 0x00	; 0
     ce0:	b6 01       	movw	r22, r12
     ce2:	9b d1       	rcall	.+822    	; 0x101a <memcpy>
			 */
			static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_SelectEndpoint(const uint8_t Address)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UENUM = (Address & ENDPOINT_EPNUM_MASK);
     ce4:	10 92 e9 00 	sts	0x00E9, r1	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>
			 *  \note This is not applicable for non CONTROL type endpoints.
			 */
			static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearSETUP(void)
			{
				UEINTX &= ~(1 << RXSTPI);
     ce8:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     cec:	87 7f       	andi	r24, 0xF7	; 247
     cee:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>

				Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);

				Endpoint_ClearSETUP();

				if (ReportID)
     cf2:	8b 81       	ldd	r24, Y+3	; 0x03
     cf4:	81 11       	cpse	r24, r1
			 *  \param[in] Data  Data to write into the the currently selected endpoint's FIFO buffer.
			 */
			static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_Write_8(const uint8_t Data)
			{
				UEDATX = Data;
     cf6:	80 93 f1 00 	sts	0x00F1, r24	; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1>
				  Endpoint_Write_8(ReportID);

				Endpoint_Write_Control_Stream_LE(ReportData, ReportSize);
     cfa:	69 81       	ldd	r22, Y+1	; 0x01
     cfc:	7a 81       	ldd	r23, Y+2	; 0x02
     cfe:	c6 01       	movw	r24, r12
     d00:	1e db       	rcall	.-2500   	; 0x33e <Endpoint_Write_Control_Stream_LE>
			 */
			static inline void Endpoint_ClearOUT(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearOUT(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UEINTX &= ~((1 << RXOUTI) | (1 << FIFOCON));
     d02:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     d06:	8b 77       	andi	r24, 0x7B	; 123
     d08:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     d0c:	37 c0       	rjmp	.+110    	; 0xd7c <HID_Device_ProcessControlRequest+0x17a>
				Endpoint_ClearOUT();
			}

			break;
		case HID_REQ_SetReport:
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
     d0e:	80 91 19 01 	lds	r24, 0x0119	; 0x800119 <USB_ControlRequest>
     d12:	81 32       	cpi	r24, 0x21	; 33
     d14:	09 f0       	breq	.+2      	; 0xd18 <HID_Device_ProcessControlRequest+0x116>
     d16:	91 c0       	rjmp	.+290    	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
			{
     d18:	8d b6       	in	r8, 0x3d	; 61
     d1a:	9e b6       	in	r9, 0x3e	; 62
				uint16_t ReportSize = USB_ControlRequest.wLength;
     d1c:	00 91 1f 01 	lds	r16, 0x011F	; 0x80011f <USB_ControlRequest+0x6>
     d20:	10 91 20 01 	lds	r17, 0x0120	; 0x800120 <USB_ControlRequest+0x7>
				uint8_t  ReportID   = (USB_ControlRequest.wValue & 0xFF);
     d24:	70 90 1b 01 	lds	r7, 0x011B	; 0x80011b <USB_ControlRequest+0x2>
     d28:	60 90 1c 01 	lds	r6, 0x011C	; 0x80011c <USB_ControlRequest+0x3>
				uint8_t  ReportType = (USB_ControlRequest.wValue >> 8) - 1;
				uint8_t  ReportData[ReportSize];
     d2c:	8d b7       	in	r24, 0x3d	; 61
     d2e:	9e b7       	in	r25, 0x3e	; 62
     d30:	80 1b       	sub	r24, r16
     d32:	91 0b       	sbc	r25, r17
     d34:	0f b6       	in	r0, 0x3f	; 63
     d36:	f8 94       	cli
     d38:	9e bf       	out	0x3e, r25	; 62
     d3a:	0f be       	out	0x3f, r0	; 63
     d3c:	8d bf       	out	0x3d, r24	; 61
     d3e:	ed b7       	in	r30, 0x3d	; 61
     d40:	fe b7       	in	r31, 0x3e	; 62
     d42:	31 96       	adiw	r30, 0x01	; 1
     d44:	6f 01       	movw	r12, r30
			 *  \note This is not applicable for non CONTROL type endpoints.
			 */
			static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearSETUP(void)
			{
				UEINTX &= ~(1 << RXSTPI);
     d46:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     d4a:	87 7f       	andi	r24, 0xF7	; 247
     d4c:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>

				Endpoint_ClearSETUP();
				Endpoint_Read_Control_Stream_LE(ReportData, ReportSize);
     d50:	b8 01       	movw	r22, r16
     d52:	cf 01       	movw	r24, r30
     d54:	52 db       	rcall	.-2396   	; 0x3fa <Endpoint_Read_Control_Stream_LE>
			 */
			static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearIN(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
     d56:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     d5a:	8e 77       	andi	r24, 0x7E	; 126
     d5c:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
				Endpoint_ClearIN();

				CALLBACK_HID_Device_ProcessHIDReport(HIDInterfaceInfo, ReportID, ReportType,
     d60:	21 e0       	ldi	r18, 0x01	; 1
     d62:	71 10       	cpse	r7, r1
     d64:	01 c0       	rjmp	.+2      	; 0xd68 <HID_Device_ProcessControlRequest+0x166>
     d66:	20 e0       	ldi	r18, 0x00	; 0
     d68:	30 e0       	ldi	r19, 0x00	; 0
     d6a:	02 1b       	sub	r16, r18
     d6c:	13 0b       	sbc	r17, r19
				                                     &ReportData[ReportID ? 1 : 0], ReportSize - (ReportID ? 1 : 0));
     d6e:	2c 0d       	add	r18, r12

				Endpoint_ClearSETUP();
				Endpoint_Read_Control_Stream_LE(ReportData, ReportSize);
				Endpoint_ClearIN();

				CALLBACK_HID_Device_ProcessHIDReport(HIDInterfaceInfo, ReportID, ReportType,
     d70:	3d 1d       	adc	r19, r13
     d72:	4f ef       	ldi	r20, 0xFF	; 255
     d74:	46 0d       	add	r20, r6
     d76:	67 2d       	mov	r22, r7
     d78:	c7 01       	movw	r24, r14
     d7a:	55 da       	rcall	.-2902   	; 0x226 <CALLBACK_HID_Device_ProcessHIDReport>
     d7c:	0f b6       	in	r0, 0x3f	; 63
     d7e:	f8 94       	cli
     d80:	9e be       	out	0x3e, r9	; 62
     d82:	0f be       	out	0x3f, r0	; 63
     d84:	8d be       	out	0x3d, r8	; 61
     d86:	59 c0       	rjmp	.+178    	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
				                                     &ReportData[ReportID ? 1 : 0], ReportSize - (ReportID ? 1 : 0));
			}

			break;
		case HID_REQ_GetProtocol:
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
     d88:	80 91 19 01 	lds	r24, 0x0119	; 0x800119 <USB_ControlRequest>
     d8c:	81 3a       	cpi	r24, 0xA1	; 161
     d8e:	09 f0       	breq	.+2      	; 0xd92 <HID_Device_ProcessControlRequest+0x190>
     d90:	54 c0       	rjmp	.+168    	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
			 *  \note This is not applicable for non CONTROL type endpoints.
			 */
			static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearSETUP(void)
			{
				UEINTX &= ~(1 << RXSTPI);
     d92:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     d96:	87 7f       	andi	r24, 0xF7	; 247
     d98:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
			 *  \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsINReady(void)
			{
				return ((UEINTX & (1 << TXINI)) ? true : false);
     d9c:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
			{
				Endpoint_ClearSETUP();
				while (!(Endpoint_IsINReady()));
     da0:	80 ff       	sbrs	r24, 0
     da2:	fc cf       	rjmp	.-8      	; 0xd9c <HID_Device_ProcessControlRequest+0x19a>
				Endpoint_Write_8(HIDInterfaceInfo->State.UsingReportProtocol);
     da4:	f7 01       	movw	r30, r14
     da6:	81 85       	ldd	r24, Z+9	; 0x09
     da8:	40 c0       	rjmp	.+128    	; 0xe2a <HID_Device_ProcessControlRequest+0x228>
				Endpoint_ClearStatusStage();
			}

			break;
		case HID_REQ_SetProtocol:
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
     daa:	80 91 19 01 	lds	r24, 0x0119	; 0x800119 <USB_ControlRequest>
     dae:	81 32       	cpi	r24, 0x21	; 33
     db0:	09 f0       	breq	.+2      	; 0xdb4 <HID_Device_ProcessControlRequest+0x1b2>
			 *  \note This is not applicable for non CONTROL type endpoints.
			 */
			static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearSETUP(void)
			{
				UEINTX &= ~(1 << RXSTPI);
     db2:	43 c0       	rjmp	.+134    	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
     db4:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     db8:	87 7f       	andi	r24, 0xF7	; 247
     dba:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
			{
				Endpoint_ClearSETUP();
				Endpoint_ClearStatusStage();
     dbe:	30 dc       	rcall	.-1952   	; 0x620 <Endpoint_ClearStatusStage>

				HIDInterfaceInfo->State.UsingReportProtocol = ((USB_ControlRequest.wValue & 0xFF) != 0x00);
     dc0:	90 91 1b 01 	lds	r25, 0x011B	; 0x80011b <USB_ControlRequest+0x2>
     dc4:	81 e0       	ldi	r24, 0x01	; 1
     dc6:	91 11       	cpse	r25, r1
     dc8:	01 c0       	rjmp	.+2      	; 0xdcc <HID_Device_ProcessControlRequest+0x1ca>
     dca:	80 e0       	ldi	r24, 0x00	; 0
     dcc:	f7 01       	movw	r30, r14
     dce:	81 87       	std	Z+9, r24	; 0x09
     dd0:	34 c0       	rjmp	.+104    	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
			}

			break;
		case HID_REQ_SetIdle:
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
     dd2:	80 91 19 01 	lds	r24, 0x0119	; 0x800119 <USB_ControlRequest>
     dd6:	81 32       	cpi	r24, 0x21	; 33
     dd8:	81 f5       	brne	.+96     	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
     dda:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     dde:	87 7f       	andi	r24, 0xF7	; 247
     de0:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
			{
				Endpoint_ClearSETUP();
				Endpoint_ClearStatusStage();
     de4:	1d dc       	rcall	.-1990   	; 0x620 <Endpoint_ClearStatusStage>

				HIDInterfaceInfo->State.IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
     de6:	80 91 1b 01 	lds	r24, 0x011B	; 0x80011b <USB_ControlRequest+0x2>
     dea:	90 91 1c 01 	lds	r25, 0x011C	; 0x80011c <USB_ControlRequest+0x3>
     dee:	88 27       	eor	r24, r24
     df0:	36 e0       	ldi	r19, 0x06	; 6
     df2:	96 95       	lsr	r25
     df4:	87 95       	ror	r24
     df6:	3a 95       	dec	r19
     df8:	e1 f7       	brne	.-8      	; 0xdf2 <HID_Device_ProcessControlRequest+0x1f0>
     dfa:	f7 01       	movw	r30, r14
     dfc:	95 87       	std	Z+13, r25	; 0x0d
     dfe:	84 87       	std	Z+12, r24	; 0x0c
     e00:	1c c0       	rjmp	.+56     	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
			}

			break;
		case HID_REQ_GetIdle:
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
     e02:	80 91 19 01 	lds	r24, 0x0119	; 0x800119 <USB_ControlRequest>
     e06:	81 3a       	cpi	r24, 0xA1	; 161
     e08:	c1 f4       	brne	.+48     	; 0xe3a <HID_Device_ProcessControlRequest+0x238>
     e0a:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     e0e:	87 7f       	andi	r24, 0xF7	; 247
     e10:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
			 *  \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
			 */
			static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsINReady(void)
			{
				return ((UEINTX & (1 << TXINI)) ? true : false);
     e14:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
			{
				Endpoint_ClearSETUP();
				while (!(Endpoint_IsINReady()));
     e18:	80 ff       	sbrs	r24, 0
     e1a:	fc cf       	rjmp	.-8      	; 0xe14 <HID_Device_ProcessControlRequest+0x212>
				Endpoint_Write_8(HIDInterfaceInfo->State.IdleCount >> 2);
     e1c:	f7 01       	movw	r30, r14
     e1e:	84 85       	ldd	r24, Z+12	; 0x0c
     e20:	95 85       	ldd	r25, Z+13	; 0x0d
     e22:	96 95       	lsr	r25
     e24:	87 95       	ror	r24
     e26:	96 95       	lsr	r25
			 *  \param[in] Data  Data to write into the the currently selected endpoint's FIFO buffer.
			 */
			static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_Write_8(const uint8_t Data)
			{
				UEDATX = Data;
     e28:	87 95       	ror	r24
     e2a:	80 93 f1 00 	sts	0x00F1, r24	; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1>
			 */
			static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearIN(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
     e2e:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     e32:	8e 77       	andi	r24, 0x7E	; 126
     e34:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
				Endpoint_ClearIN();
				Endpoint_ClearStatusStage();
     e38:	f3 db       	rcall	.-2074   	; 0x620 <Endpoint_ClearStatusStage>
			}

			break;
	}
}
     e3a:	0f b6       	in	r0, 0x3f	; 63
     e3c:	f8 94       	cli
     e3e:	be be       	out	0x3e, r11	; 62
     e40:	0f be       	out	0x3f, r0	; 63
     e42:	ad be       	out	0x3d, r10	; 61
     e44:	0f 90       	pop	r0
     e46:	0f 90       	pop	r0
     e48:	0f 90       	pop	r0
     e4a:	df 91       	pop	r29
     e4c:	cf 91       	pop	r28
     e4e:	1f 91       	pop	r17
     e50:	0f 91       	pop	r16
     e52:	ff 90       	pop	r15
     e54:	ef 90       	pop	r14
     e56:	df 90       	pop	r13
     e58:	cf 90       	pop	r12
     e5a:	bf 90       	pop	r11
     e5c:	af 90       	pop	r10
     e5e:	9f 90       	pop	r9
     e60:	8f 90       	pop	r8
     e62:	7f 90       	pop	r7
     e64:	6f 90       	pop	r6
     e66:	08 95       	ret

00000e68 <HID_Device_ConfigureEndpoints>:

bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
{
	memset(&HIDInterfaceInfo->State, 0x00, sizeof(HIDInterfaceInfo->State));
     e68:	fc 01       	movw	r30, r24
     e6a:	39 96       	adiw	r30, 0x09	; 9
     e6c:	27 e0       	ldi	r18, 0x07	; 7
     e6e:	df 01       	movw	r26, r30
     e70:	1d 92       	st	X+, r1
     e72:	2a 95       	dec	r18
     e74:	e9 f7       	brne	.-6      	; 0xe70 <HID_Device_ConfigureEndpoints+0x8>
	HIDInterfaceInfo->State.UsingReportProtocol = true;
     e76:	21 e0       	ldi	r18, 0x01	; 1
     e78:	fc 01       	movw	r30, r24
     e7a:	21 87       	std	Z+9, r18	; 0x09
	HIDInterfaceInfo->State.IdleCount           = 500;
     e7c:	24 ef       	ldi	r18, 0xF4	; 244
     e7e:	31 e0       	ldi	r19, 0x01	; 1
     e80:	35 87       	std	Z+13, r19	; 0x0d
     e82:	24 87       	std	Z+12, r18	; 0x0c

	HIDInterfaceInfo->Config.ReportINEndpoint.Type = EP_TYPE_INTERRUPT;
     e84:	23 e0       	ldi	r18, 0x03	; 3
     e86:	24 83       	std	Z+4, r18	; 0x04

	if (!(Endpoint_ConfigureEndpointTable(&HIDInterfaceInfo->Config.ReportINEndpoint, 1)))
     e88:	61 e0       	ldi	r22, 0x01	; 1
     e8a:	01 96       	adiw	r24, 0x01	; 1
     e8c:	8c cb       	rjmp	.-2280   	; 0x5a6 <Endpoint_ConfigureEndpointTable>

00000e8e <HID_Device_USBTask>:

	return true;
}

void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
{
     e8e:	5f 92       	push	r5
     e90:	6f 92       	push	r6
     e92:	7f 92       	push	r7
     e94:	8f 92       	push	r8
     e96:	9f 92       	push	r9
     e98:	af 92       	push	r10
     e9a:	bf 92       	push	r11
     e9c:	cf 92       	push	r12
     e9e:	df 92       	push	r13
     ea0:	ef 92       	push	r14
     ea2:	ff 92       	push	r15
     ea4:	0f 93       	push	r16
     ea6:	1f 93       	push	r17
     ea8:	cf 93       	push	r28
     eaa:	df 93       	push	r29
     eac:	00 d0       	rcall	.+0      	; 0xeae <HID_Device_USBTask+0x20>
     eae:	1f 92       	push	r1
     eb0:	cd b7       	in	r28, 0x3d	; 61
     eb2:	de b7       	in	r29, 0x3e	; 62
     eb4:	7c 01       	movw	r14, r24
			Endpoint_ClearIN();
		}

		HIDInterfaceInfo->State.PrevFrameNum = USB_Device_GetFrameNumber();
	}
}
     eb6:	ad b6       	in	r10, 0x3d	; 61
     eb8:	be b6       	in	r11, 0x3e	; 62
	return true;
}

void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
{
	if (USB_DeviceState != DEVICE_STATE_Configured)
     eba:	80 91 18 01 	lds	r24, 0x0118	; 0x800118 <USB_DeviceState>
     ebe:	84 30       	cpi	r24, 0x04	; 4
     ec0:	09 f0       	breq	.+2      	; 0xec4 <HID_Device_USBTask+0x36>
     ec2:	86 c0       	rjmp	.+268    	; 0xfd0 <HID_Device_USBTask+0x142>
			 *  \return Current USB frame number from the USB controller.
			 */
			static inline uint16_t USB_Device_GetFrameNumber(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
			static inline uint16_t USB_Device_GetFrameNumber(void)
			{
				return UDFNUM;
     ec4:	80 91 e4 00 	lds	r24, 0x00E4	; 0x8000e4 <__TEXT_REGION_LENGTH__+0x7e00e4>
     ec8:	90 91 e5 00 	lds	r25, 0x00E5	; 0x8000e5 <__TEXT_REGION_LENGTH__+0x7e00e5>
	  return;

	if (HIDInterfaceInfo->State.PrevFrameNum == USB_Device_GetFrameNumber())
     ecc:	f7 01       	movw	r30, r14
     ece:	22 85       	ldd	r18, Z+10	; 0x0a
     ed0:	33 85       	ldd	r19, Z+11	; 0x0b
     ed2:	28 17       	cp	r18, r24
     ed4:	39 07       	cpc	r19, r25
     ed6:	09 f4       	brne	.+2      	; 0xeda <HID_Device_USBTask+0x4c>
     ed8:	7b c0       	rjmp	.+246    	; 0xfd0 <HID_Device_USBTask+0x142>
			 */
			static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_SelectEndpoint(const uint8_t Address)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UENUM = (Address & ENDPOINT_EPNUM_MASK);
     eda:	81 81       	ldd	r24, Z+1	; 0x01
     edc:	8f 70       	andi	r24, 0x0F	; 15
     ede:	80 93 e9 00 	sts	0x00E9, r24	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>
			 *          on its direction.
			 */
			static inline bool Endpoint_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
			static inline bool Endpoint_IsReadWriteAllowed(void)
			{
				return ((UEINTX & (1 << RWAL)) ? true : false);
     ee2:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
		#endif
	}

	Endpoint_SelectEndpoint(HIDInterfaceInfo->Config.ReportINEndpoint.Address);

	if (Endpoint_IsReadWriteAllowed())
     ee6:	85 ff       	sbrs	r24, 5
     ee8:	73 c0       	rjmp	.+230    	; 0xfd0 <HID_Device_USBTask+0x142>
	{
     eea:	8d b6       	in	r8, 0x3d	; 61
     eec:	9e b6       	in	r9, 0x3e	; 62
		uint8_t  ReportINData[HIDInterfaceInfo->Config.PrevReportINBufferSize];
     eee:	40 85       	ldd	r20, Z+8	; 0x08
     ef0:	50 e0       	ldi	r21, 0x00	; 0
     ef2:	8d b7       	in	r24, 0x3d	; 61
     ef4:	9e b7       	in	r25, 0x3e	; 62
     ef6:	84 1b       	sub	r24, r20
     ef8:	95 0b       	sbc	r25, r21
     efa:	0f b6       	in	r0, 0x3f	; 63
     efc:	f8 94       	cli
     efe:	9e bf       	out	0x3e, r25	; 62
     f00:	0f be       	out	0x3f, r0	; 63
     f02:	8d bf       	out	0x3d, r24	; 61
     f04:	ed b7       	in	r30, 0x3d	; 61
     f06:	fe b7       	in	r31, 0x3e	; 62
     f08:	31 96       	adiw	r30, 0x01	; 1
     f0a:	6f 01       	movw	r12, r30
		uint8_t  ReportID     = 0;
     f0c:	1b 82       	std	Y+3, r1	; 0x03
		uint16_t ReportINSize = 0;
     f0e:	1a 82       	std	Y+2, r1	; 0x02
     f10:	19 82       	std	Y+1, r1	; 0x01

		memset(ReportINData, 0, sizeof(ReportINData));
     f12:	60 e0       	ldi	r22, 0x00	; 0
     f14:	70 e0       	ldi	r23, 0x00	; 0
     f16:	cf 01       	movw	r24, r30
     f18:	89 d0       	rcall	.+274    	; 0x102c <memset>

		bool ForceSend         = CALLBACK_HID_Device_CreateHIDReport(HIDInterfaceInfo, &ReportID, HID_REPORT_ITEM_In,
     f1a:	8e 01       	movw	r16, r28
     f1c:	0f 5f       	subi	r16, 0xFF	; 255
     f1e:	1f 4f       	sbci	r17, 0xFF	; 255
     f20:	96 01       	movw	r18, r12
     f22:	40 e0       	ldi	r20, 0x00	; 0
     f24:	be 01       	movw	r22, r28
     f26:	6d 5f       	subi	r22, 0xFD	; 253
     f28:	7f 4f       	sbci	r23, 0xFF	; 255
     f2a:	c7 01       	movw	r24, r14
     f2c:	71 d9       	rcall	.-3358   	; 0x210 <CALLBACK_HID_Device_CreateHIDReport>
     f2e:	58 2e       	mov	r5, r24
		                                                             ReportINData, &ReportINSize);
		bool StatesChanged     = false;
		bool IdlePeriodElapsed = (HIDInterfaceInfo->State.IdleCount && !(HIDInterfaceInfo->State.IdleMSRemaining));
     f30:	f7 01       	movw	r30, r14
     f32:	84 85       	ldd	r24, Z+12	; 0x0c
     f34:	95 85       	ldd	r25, Z+13	; 0x0d
     f36:	89 2b       	or	r24, r25
     f38:	29 f0       	breq	.+10     	; 0xf44 <HID_Device_USBTask+0xb6>
     f3a:	11 e0       	ldi	r17, 0x01	; 1
     f3c:	86 85       	ldd	r24, Z+14	; 0x0e
     f3e:	97 85       	ldd	r25, Z+15	; 0x0f
     f40:	89 2b       	or	r24, r25
     f42:	09 f0       	breq	.+2      	; 0xf46 <HID_Device_USBTask+0xb8>
     f44:	10 e0       	ldi	r17, 0x00	; 0

		if (HIDInterfaceInfo->Config.PrevReportINBuffer != NULL)
     f46:	f7 01       	movw	r30, r14
     f48:	66 80       	ldd	r6, Z+6	; 0x06
     f4a:	77 80       	ldd	r7, Z+7	; 0x07
     f4c:	61 14       	cp	r6, r1
     f4e:	71 04       	cpc	r7, r1
     f50:	81 f0       	breq	.+32     	; 0xf72 <HID_Device_USBTask+0xe4>
		{
			StatesChanged = (memcmp(ReportINData, HIDInterfaceInfo->Config.PrevReportINBuffer, ReportINSize) != 0);
     f52:	49 81       	ldd	r20, Y+1	; 0x01
     f54:	5a 81       	ldd	r21, Y+2	; 0x02
     f56:	b3 01       	movw	r22, r6
     f58:	c6 01       	movw	r24, r12
     f5a:	52 d0       	rcall	.+164    	; 0x1000 <memcmp>
     f5c:	01 e0       	ldi	r16, 0x01	; 1
     f5e:	89 2b       	or	r24, r25
     f60:	09 f4       	brne	.+2      	; 0xf64 <HID_Device_USBTask+0xd6>
     f62:	00 e0       	ldi	r16, 0x00	; 0
			memcpy(HIDInterfaceInfo->Config.PrevReportINBuffer, ReportINData, HIDInterfaceInfo->Config.PrevReportINBufferSize);
     f64:	f7 01       	movw	r30, r14
     f66:	40 85       	ldd	r20, Z+8	; 0x08
     f68:	50 e0       	ldi	r21, 0x00	; 0
     f6a:	b6 01       	movw	r22, r12
     f6c:	c3 01       	movw	r24, r6
     f6e:	55 d0       	rcall	.+170    	; 0x101a <memcpy>
     f70:	01 c0       	rjmp	.+2      	; 0xf74 <HID_Device_USBTask+0xe6>

		memset(ReportINData, 0, sizeof(ReportINData));

		bool ForceSend         = CALLBACK_HID_Device_CreateHIDReport(HIDInterfaceInfo, &ReportID, HID_REPORT_ITEM_In,
		                                                             ReportINData, &ReportINSize);
		bool StatesChanged     = false;
     f72:	00 e0       	ldi	r16, 0x00	; 0
		{
			StatesChanged = (memcmp(ReportINData, HIDInterfaceInfo->Config.PrevReportINBuffer, ReportINSize) != 0);
			memcpy(HIDInterfaceInfo->Config.PrevReportINBuffer, ReportINData, HIDInterfaceInfo->Config.PrevReportINBufferSize);
		}

		if (ReportINSize && (ForceSend || StatesChanged || IdlePeriodElapsed))
     f74:	89 81       	ldd	r24, Y+1	; 0x01
     f76:	9a 81       	ldd	r25, Y+2	; 0x02
     f78:	89 2b       	or	r24, r25
     f7a:	f1 f0       	breq	.+60     	; 0xfb8 <HID_Device_USBTask+0x12a>
     f7c:	51 10       	cpse	r5, r1
     f7e:	04 c0       	rjmp	.+8      	; 0xf88 <HID_Device_USBTask+0xfa>
     f80:	01 11       	cpse	r16, r1
     f82:	02 c0       	rjmp	.+4      	; 0xf88 <HID_Device_USBTask+0xfa>
     f84:	10 ff       	sbrs	r17, 0
     f86:	18 c0       	rjmp	.+48     	; 0xfb8 <HID_Device_USBTask+0x12a>
		{
			HIDInterfaceInfo->State.IdleMSRemaining = HIDInterfaceInfo->State.IdleCount;
     f88:	f7 01       	movw	r30, r14
     f8a:	84 85       	ldd	r24, Z+12	; 0x0c
     f8c:	95 85       	ldd	r25, Z+13	; 0x0d
     f8e:	97 87       	std	Z+15, r25	; 0x0f
     f90:	86 87       	std	Z+14, r24	; 0x0e
			 */
			static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_SelectEndpoint(const uint8_t Address)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UENUM = (Address & ENDPOINT_EPNUM_MASK);
     f92:	81 81       	ldd	r24, Z+1	; 0x01
     f94:	8f 70       	andi	r24, 0x0F	; 15
     f96:	80 93 e9 00 	sts	0x00E9, r24	; 0x8000e9 <__TEXT_REGION_LENGTH__+0x7e00e9>

			Endpoint_SelectEndpoint(HIDInterfaceInfo->Config.ReportINEndpoint.Address);

			if (ReportID)
     f9a:	8b 81       	ldd	r24, Y+3	; 0x03
     f9c:	81 11       	cpse	r24, r1
			 *  \param[in] Data  Data to write into the the currently selected endpoint's FIFO buffer.
			 */
			static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_Write_8(const uint8_t Data)
			{
				UEDATX = Data;
     f9e:	80 93 f1 00 	sts	0x00F1, r24	; 0x8000f1 <__TEXT_REGION_LENGTH__+0x7e00f1>
			  Endpoint_Write_8(ReportID);

			Endpoint_Write_Stream_LE(ReportINData, ReportINSize, NULL);
     fa2:	69 81       	ldd	r22, Y+1	; 0x01
     fa4:	7a 81       	ldd	r23, Y+2	; 0x02
     fa6:	40 e0       	ldi	r20, 0x00	; 0
     fa8:	50 e0       	ldi	r21, 0x00	; 0
     faa:	c6 01       	movw	r24, r12
     fac:	7e d9       	rcall	.-3332   	; 0x2aa <Endpoint_Write_Stream_LE>
			 */
			static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearIN(void)
			{
				#if !defined(CONTROL_ONLY_DEVICE)
					UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
     fae:	80 91 e8 00 	lds	r24, 0x00E8	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     fb2:	8e 77       	andi	r24, 0x7E	; 126
     fb4:	80 93 e8 00 	sts	0x00E8, r24	; 0x8000e8 <__TEXT_REGION_LENGTH__+0x7e00e8>
     fb8:	80 91 e4 00 	lds	r24, 0x00E4	; 0x8000e4 <__TEXT_REGION_LENGTH__+0x7e00e4>
     fbc:	90 91 e5 00 	lds	r25, 0x00E5	; 0x8000e5 <__TEXT_REGION_LENGTH__+0x7e00e5>

			Endpoint_ClearIN();
		}

		HIDInterfaceInfo->State.PrevFrameNum = USB_Device_GetFrameNumber();
     fc0:	f7 01       	movw	r30, r14
     fc2:	93 87       	std	Z+11, r25	; 0x0b
     fc4:	82 87       	std	Z+10, r24	; 0x0a
     fc6:	0f b6       	in	r0, 0x3f	; 63
     fc8:	f8 94       	cli
     fca:	9e be       	out	0x3e, r9	; 62
     fcc:	0f be       	out	0x3f, r0	; 63
     fce:	8d be       	out	0x3d, r8	; 61
	}
}
     fd0:	0f b6       	in	r0, 0x3f	; 63
     fd2:	f8 94       	cli
     fd4:	be be       	out	0x3e, r11	; 62
     fd6:	0f be       	out	0x3f, r0	; 63
     fd8:	ad be       	out	0x3d, r10	; 61
     fda:	0f 90       	pop	r0
     fdc:	0f 90       	pop	r0
     fde:	0f 90       	pop	r0
     fe0:	df 91       	pop	r29
     fe2:	cf 91       	pop	r28
     fe4:	1f 91       	pop	r17
     fe6:	0f 91       	pop	r16
     fe8:	ff 90       	pop	r15
     fea:	ef 90       	pop	r14
     fec:	df 90       	pop	r13
     fee:	cf 90       	pop	r12
     ff0:	bf 90       	pop	r11
     ff2:	af 90       	pop	r10
     ff4:	9f 90       	pop	r9
     ff6:	8f 90       	pop	r8
     ff8:	7f 90       	pop	r7
     ffa:	6f 90       	pop	r6
     ffc:	5f 90       	pop	r5
     ffe:	08 95       	ret

00001000 <memcmp>:
    1000:	fb 01       	movw	r30, r22
    1002:	dc 01       	movw	r26, r24
    1004:	04 c0       	rjmp	.+8      	; 0x100e <memcmp+0xe>
    1006:	8d 91       	ld	r24, X+
    1008:	01 90       	ld	r0, Z+
    100a:	80 19       	sub	r24, r0
    100c:	21 f4       	brne	.+8      	; 0x1016 <memcmp+0x16>
    100e:	41 50       	subi	r20, 0x01	; 1
    1010:	50 40       	sbci	r21, 0x00	; 0
    1012:	c8 f7       	brcc	.-14     	; 0x1006 <memcmp+0x6>
    1014:	88 1b       	sub	r24, r24
    1016:	99 0b       	sbc	r25, r25
    1018:	08 95       	ret

0000101a <memcpy>:
    101a:	fb 01       	movw	r30, r22
    101c:	dc 01       	movw	r26, r24
    101e:	02 c0       	rjmp	.+4      	; 0x1024 <memcpy+0xa>
    1020:	01 90       	ld	r0, Z+
    1022:	0d 92       	st	X+, r0
    1024:	41 50       	subi	r20, 0x01	; 1
    1026:	50 40       	sbci	r21, 0x00	; 0
    1028:	d8 f7       	brcc	.-10     	; 0x1020 <memcpy+0x6>
    102a:	08 95       	ret

0000102c <memset>:
    102c:	dc 01       	movw	r26, r24
    102e:	01 c0       	rjmp	.+2      	; 0x1032 <memset+0x6>
    1030:	6d 93       	st	X+, r22
    1032:	41 50       	subi	r20, 0x01	; 1
    1034:	50 40       	sbci	r21, 0x00	; 0
    1036:	e0 f7       	brcc	.-8      	; 0x1030 <memset+0x4>
    1038:	08 95       	ret

0000103a <_exit>:
    103a:	f8 94       	cli

0000103c <__stop_program>:
    103c:	ff cf       	rjmp	.-2      	; 0x103c <__stop_program>