
LOWLEVEL_CDC1.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .data         0000000e  00800100  00000dea  00000e7e  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  1 .text         00000dea  00000000  00000000  00000094  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .bss          0000000e  0080010e  0080010e  00000e8c  2**0
                  ALLOC
  3 .comment      00000030  00000000  00000000  00000e8c  2**0
                  CONTENTS, READONLY
  4 .debug_aranges 000006a0  00000000  00000000  00000ebc  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_info   0000a754  00000000  00000000  0000155c  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_abbrev 00002b04  00000000  00000000  0000bcb0  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_line   00014421  00000000  00000000  0000e7b4  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_frame  00001168  00000000  00000000  00022bd8  2**2
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_str    00019916  00000000  00000000  00023d40  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_loc    000072a5  00000000  00000000  0003d656  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_ranges 00001058  00000000  00000000  000448fb  2**0
                  CONTENTS, READONLY, DEBUGGING
 12 .debug_macro  0000ad74  00000000  00000000  00045953  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
   0:	a5 c0       	rjmp	.+330    	; 0x14c <__ctors_end>
   2:	00 00       	nop
   4:	be c0       	rjmp	.+380    	; 0x182 <__bad_interrupt>
   6:	00 00       	nop
   8:	bc c0       	rjmp	.+376    	; 0x182 <__bad_interrupt>
   a:	00 00       	nop
   c:	ba c0       	rjmp	.+372    	; 0x182 <__bad_interrupt>
   e:	00 00       	nop
  10:	b8 c0       	rjmp	.+368    	; 0x182 <__bad_interrupt>
  12:	00 00       	nop
  14:	b6 c0       	rjmp	.+364    	; 0x182 <__bad_interrupt>
  16:	00 00       	nop
  18:	b4 c0       	rjmp	.+360    	; 0x182 <__bad_interrupt>
  1a:	00 00       	nop
  1c:	b2 c0       	rjmp	.+356    	; 0x182 <__bad_interrupt>
  1e:	00 00       	nop
  20:	b0 c0       	rjmp	.+352    	; 0x182 <__bad_interrupt>
  22:	00 00       	nop
  24:	ae c0       	rjmp	.+348    	; 0x182 <__bad_interrupt>
  26:	00 00       	nop
  28:	ed c3       	rjmp	.+2010   	; 0x804 <__vector_10>
  2a:	00 00       	nop
  2c:	aa c0       	rjmp	.+340    	; 0x182 <__bad_interrupt>
  2e:	00 00       	nop
  30:	a8 c0       	rjmp	.+336    	; 0x182 <__bad_interrupt>
  32:	00 00       	nop
  34:	a6 c0       	rjmp	.+332    	; 0x182 <__bad_interrupt>
  36:	00 00       	nop
  38:	a4 c0       	rjmp	.+328    	; 0x182 <__bad_interrupt>
  3a:	00 00       	nop
  3c:	a2 c0       	rjmp	.+324    	; 0x182 <__bad_interrupt>
  3e:	00 00       	nop
  40:	a0 c0       	rjmp	.+320    	; 0x182 <__bad_interrupt>
  42:	00 00       	nop
  44:	9e c0       	rjmp	.+316    	; 0x182 <__bad_interrupt>
  46:	00 00       	nop
  48:	9c c0       	rjmp	.+312    	; 0x182 <__bad_interrupt>
  4a:	00 00       	nop
  4c:	9a c0       	rjmp	.+308    	; 0x182 <__bad_interrupt>
  4e:	00 00       	nop
  50:	98 c0       	rjmp	.+304    	; 0x182 <__bad_interrupt>
  52:	00 00       	nop
  54:	96 c0       	rjmp	.+300    	; 0x182 <__bad_interrupt>
  56:	00 00       	nop
  58:	94 c0       	rjmp	.+296    	; 0x182 <__bad_interrupt>
  5a:	00 00       	nop
  5c:	92 c0       	rjmp	.+292    	; 0x182 <__bad_interrupt>
  5e:	00 00       	nop
  60:	90 c0       	rjmp	.+288    	; 0x182 <__bad_interrupt>
  62:	00 00       	nop
  64:	8e c0       	rjmp	.+284    	; 0x182 <__bad_interrupt>
  66:	00 00       	nop
  68:	8c c0       	rjmp	.+280    	; 0x182 <__bad_interrupt>
  6a:	00 00       	nop
  6c:	8a c0       	rjmp	.+276    	; 0x182 <__bad_interrupt>
  6e:	00 00       	nop
  70:	88 c0       	rjmp	.+272    	; 0x182 <__bad_interrupt>
  72:	00 00       	nop
  74:	86 c0       	rjmp	.+268    	; 0x182 <__bad_interrupt>
  76:	00 00       	nop
  78:	84 c0       	rjmp	.+264    	; 0x182 <__bad_interrupt>
  7a:	00 00       	nop
  7c:	82 c0       	rjmp	.+260    	; 0x182 <__bad_interrupt>
  7e:	00 00       	nop
  80:	80 c0       	rjmp	.+256    	; 0x182 <__bad_interrupt>
  82:	00 00       	nop
  84:	7e c0       	rjmp	.+252    	; 0x182 <__bad_interrupt>
  86:	00 00       	nop
  88:	7c c0       	rjmp	.+248    	; 0x182 <__bad_interrupt>
  8a:	00 00       	nop
  8c:	7a c0       	rjmp	.+244    	; 0x182 <__bad_interrupt>
  8e:	00 00       	nop
  90:	78 c0       	rjmp	.+240    	; 0x182 <__bad_interrupt>
  92:	00 00       	nop
  94:	76 c0       	rjmp	.+236    	; 0x182 <__bad_interrupt>
  96:	00 00       	nop
  98:	74 c0       	rjmp	.+232    	; 0x182 <__bad_interrupt>
  9a:	00 00       	nop
  9c:	72 c0       	rjmp	.+228    	; 0x182 <__bad_interrupt>
  9e:	00 00       	nop
  a0:	70 c0       	rjmp	.+224    	; 0x182 <__bad_interrupt>
  a2:	00 00       	nop
  a4:	6e c0       	rjmp	.+220    	; 0x182 <__bad_interrupt>
  a6:	00 00       	nop
  a8:	6c c0       	rjmp	.+216    	; 0x182 <__bad_interrupt>
  aa:	00 00       	nop
  ac:	ec 04       	cpc	r14, r12
  ae:	14 05       	cpc	r17, r4
  b0:	ff 05       	cpc	r31, r15
  b2:	14 05       	cpc	r17, r4
  b4:	ff 05       	cpc	r31, r15
  b6:	53 05       	cpc	r21, r3
  b8:	76 05       	cpc	r23, r6
  ba:	ff 05       	cpc	r31, r15
  bc:	cd 05       	cpc	r28, r13
  be:	dd 05       	cpc	r29, r13

000000c0 <ProductString>:
  c0:	1c 03 4c 00 55 00 46 00 41 00 20 00 43 00 44 00     ..L.U.F.A. .C.D.
  d0:	43 00 20 00 44 00 65 00 6d 00 6f 00 00 00           C. .D.e.m.o...

000000de <ManufacturerString>:
  de:	18 03 44 00 65 00 61 00 6e 00 20 00 43 00 61 00     ..D.e.a.n. .C.a.
  ee:	6d 00 65 00 72 00 61 00 00 00                       m.e.r.a...

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

000000fc <ConfigurationDescriptor>:
  fc:	09 02 3e 00 02 01 00 c0 32 09 04 00 00 01 02 02     ..>.....2.......
 10c:	01 00 05 24 00 10 01 04 24 02 06 05 24 06 00 01     ...$....$...$...
 11c:	07 05 82 03 08 00 ff 09 04 01 00 02 0a 00 00 00     ................
 12c:	07 05 04 02 10 00 05 07 05 83 02 10 00 05           ..............

0000013a <DeviceDescriptor>:
 13a:	12 01 10 01 02 00 00 08 eb 03 44 20 01 00 01 02     ..........D ....
 14a:	dc 01                                               ..

0000014c <__ctors_end>:
 14c:	11 24       	eor	r1, r1
 14e:	1f be       	out	0x3f, r1	; 63
 150:	cf ef       	ldi	r28, 0xFF	; 255
 152:	da e0       	ldi	r29, 0x0A	; 10
 154:	de bf       	out	0x3e, r29	; 62
 156:	cd bf       	out	0x3d, r28	; 61

00000158 <__do_copy_data>:
 158:	11 e0       	ldi	r17, 0x01	; 1
 15a:	a0 e0       	ldi	r26, 0x00	; 0
 15c:	b1 e0       	ldi	r27, 0x01	; 1
 15e:	ea ee       	ldi	r30, 0xEA	; 234
 160:	fd e0       	ldi	r31, 0x0D	; 13
 162:	02 c0       	rjmp	.+4      	; 0x168 <__do_copy_data+0x10>
 164:	05 90       	lpm	r0, Z+
 166:	0d 92       	st	X+, r0
 168:	ae 30       	cpi	r26, 0x0E	; 14
 16a:	b1 07       	cpc	r27, r17
 16c:	d9 f7       	brne	.-10     	; 0x164 <__do_copy_data+0xc>

0000016e <__do_clear_bss>:
 16e:	21 e0       	ldi	r18, 0x01	; 1
 170:	ae e0       	ldi	r26, 0x0E	; 14
 172:	b1 e0       	ldi	r27, 0x01	; 1
 174:	01 c0       	rjmp	.+2      	; 0x178 <.do_clear_bss_start>

00000176 <.do_clear_bss_loop>:
 176:	1d 92       	st	X+, r1

00000178 <.do_clear_bss_start>:
 178:	ac 31       	cpi	r26, 0x1C	; 28
 17a:	b2 07       	cpc	r27, r18
 17c:	e1 f7       	brne	.-8      	; 0x176 <.do_clear_bss_loop>
 17e:	28 d6       	rcall	.+3152   	; 0xdd0 <main>
 180:	32 c6       	rjmp	.+3172   	; 0xde6 <_exit>

00000182 <__bad_interrupt>:
 182:	3e cf       	rjmp	.-388    	; 0x0 <__vectors>

00000184 <CALLBACK_USB_GetDescriptor>:
 */
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
                                    const uint8_t wIndex,
                                    const void** const DescriptorAddress)
{
	const uint8_t  DescriptorType   = (wValue >> 8);
 184:	29 2f       	mov	r18, r25
 186:	33 27       	eor	r19, r19
	const uint8_t  DescriptorNumber = (wValue & 0xFF);

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

	switch (DescriptorType)
 188:	22 30       	cpi	r18, 0x02	; 2
 18a:	31 05       	cpc	r19, r1
 18c:	59 f0       	breq	.+22     	; 0x1a4 <CALLBACK_USB_GetDescriptor+0x20>
 18e:	23 30       	cpi	r18, 0x03	; 3
 190:	31 05       	cpc	r19, r1
 192:	69 f0       	breq	.+26     	; 0x1ae <CALLBACK_USB_GetDescriptor+0x2a>
 194:	21 30       	cpi	r18, 0x01	; 1
 196:	31 05       	cpc	r19, r1
 198:	29 f1       	breq	.+74     	; 0x1e4 <CALLBACK_USB_GetDescriptor+0x60>
{
	const uint8_t  DescriptorType   = (wValue >> 8);
	const uint8_t  DescriptorNumber = (wValue & 0xFF);

	const void* Address = NULL;
	uint16_t    Size    = NO_DESCRIPTOR;
 19a:	80 e0       	ldi	r24, 0x00	; 0
 19c:	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;
 19e:	20 e0       	ldi	r18, 0x00	; 0
 1a0:	30 e0       	ldi	r19, 0x00	; 0
 1a2:	29 c0       	rjmp	.+82     	; 0x1f6 <CALLBACK_USB_GetDescriptor+0x72>
			Address = &DeviceDescriptor;
			Size    = sizeof(USB_Descriptor_Device_t);
			break;
		case DTYPE_Configuration:
			Address = &ConfigurationDescriptor;
			Size    = sizeof(USB_Descriptor_Configuration_t);
 1a4:	8e e3       	ldi	r24, 0x3E	; 62
 1a6:	90 e0       	ldi	r25, 0x00	; 0
		case DTYPE_Device:
			Address = &DeviceDescriptor;
			Size    = sizeof(USB_Descriptor_Device_t);
			break;
		case DTYPE_Configuration:
			Address = &ConfigurationDescriptor;
 1a8:	2c ef       	ldi	r18, 0xFC	; 252
 1aa:	30 e0       	ldi	r19, 0x00	; 0
			Size    = sizeof(USB_Descriptor_Configuration_t);
			break;
 1ac:	24 c0       	rjmp	.+72     	; 0x1f6 <CALLBACK_USB_GetDescriptor+0x72>
 1ae:	99 27       	eor	r25, r25
		case DTYPE_String:
			switch (DescriptorNumber)
 1b0:	81 30       	cpi	r24, 0x01	; 1
 1b2:	91 05       	cpc	r25, r1
 1b4:	59 f0       	breq	.+22     	; 0x1cc <CALLBACK_USB_GetDescriptor+0x48>
 1b6:	82 30       	cpi	r24, 0x02	; 2
 1b8:	91 05       	cpc	r25, r1
 1ba:	71 f0       	breq	.+28     	; 0x1d8 <CALLBACK_USB_GetDescriptor+0x54>
 1bc:	89 2b       	or	r24, r25
 1be:	b9 f4       	brne	.+46     	; 0x1ee <CALLBACK_USB_GetDescriptor+0x6a>
			{
				case STRING_ID_Language:
					Address = &LanguageString;
					Size    = pgm_read_byte(&LanguageString.Header.Size);
 1c0:	e8 ef       	ldi	r30, 0xF8	; 248
 1c2:	f0 e0       	ldi	r31, 0x00	; 0
 1c4:	84 91       	lpm	r24, Z
 1c6:	90 e0       	ldi	r25, 0x00	; 0
			break;
		case DTYPE_String:
			switch (DescriptorNumber)
			{
				case STRING_ID_Language:
					Address = &LanguageString;
 1c8:	9f 01       	movw	r18, r30
					Size    = pgm_read_byte(&LanguageString.Header.Size);
					break;
 1ca:	15 c0       	rjmp	.+42     	; 0x1f6 <CALLBACK_USB_GetDescriptor+0x72>
				case STRING_ID_Manufacturer:
					Address = &ManufacturerString;
					Size    = pgm_read_byte(&ManufacturerString.Header.Size);
 1cc:	ee ed       	ldi	r30, 0xDE	; 222
 1ce:	f0 e0       	ldi	r31, 0x00	; 0
 1d0:	84 91       	lpm	r24, Z
 1d2:	90 e0       	ldi	r25, 0x00	; 0
				case STRING_ID_Language:
					Address = &LanguageString;
					Size    = pgm_read_byte(&LanguageString.Header.Size);
					break;
				case STRING_ID_Manufacturer:
					Address = &ManufacturerString;
 1d4:	9f 01       	movw	r18, r30
					Size    = pgm_read_byte(&ManufacturerString.Header.Size);
					break;
 1d6:	0f c0       	rjmp	.+30     	; 0x1f6 <CALLBACK_USB_GetDescriptor+0x72>
				case STRING_ID_Product:
					Address = &ProductString;
					Size    = pgm_read_byte(&ProductString.Header.Size);
 1d8:	e0 ec       	ldi	r30, 0xC0	; 192
 1da:	f0 e0       	ldi	r31, 0x00	; 0
 1dc:	84 91       	lpm	r24, Z
 1de:	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;
 1e0:	9f 01       	movw	r18, r30
					Size    = pgm_read_byte(&ProductString.Header.Size);
					break;
 1e2:	09 c0       	rjmp	.+18     	; 0x1f6 <CALLBACK_USB_GetDescriptor+0x72>

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

	switch (DescriptorType)
	{
		case DTYPE_Device:
			Address = &DeviceDescriptor;
 1e8:	2a e3       	ldi	r18, 0x3A	; 58
 1ea:	31 e0       	ldi	r19, 0x01	; 1
 1ec:	04 c0       	rjmp	.+8      	; 0x1f6 <CALLBACK_USB_GetDescriptor+0x72>
{
	const uint8_t  DescriptorType   = (wValue >> 8);
	const uint8_t  DescriptorNumber = (wValue & 0xFF);

	const void* Address = NULL;
	uint16_t    Size    = NO_DESCRIPTOR;
 1ee:	80 e0       	ldi	r24, 0x00	; 0
 1f0:	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;
 1f2:	20 e0       	ldi	r18, 0x00	; 0
 1f4:	30 e0       	ldi	r19, 0x00	; 0
			}

			break;
	}

	*DescriptorAddress = Address;
 1f6:	fa 01       	movw	r30, r20
 1f8:	31 83       	std	Z+1, r19	; 0x01
 1fa:	20 83       	st	Z, r18
	return Size;
}
 1fc:	08 95       	ret

000001fe <Endpoint_Write_Stream_LE>:
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
		  return ENDPOINT_RWCSTREAM_BusSuspended;
	}

	return ENDPOINT_RWCSTREAM_NoError;
}
 1fe:	8f 92       	push	r8
 200:	9f 92       	push	r9
 202:	af 92       	push	r10
 204:	bf 92       	push	r11
 206:	cf 92       	push	r12
 208:	df 92       	push	r13
 20a:	ef 92       	push	r14
 20c:	ff 92       	push	r15
 20e:	0f 93       	push	r16
 210:	1f 93       	push	r17
 212:	cf 93       	push	r28
 214:	df 93       	push	r29
 216:	7c 01       	movw	r14, r24
 218:	eb 01       	movw	r28, r22
 21a:	5a 01       	movw	r10, r20
 21c:	53 d2       	rcall	.+1190   	; 0x6c4 <Endpoint_WaitUntilReady>
 21e:	81 11       	cpse	r24, r1
 220:	3e c0       	rjmp	.+124    	; 0x29e <Endpoint_Write_Stream_LE+0xa0>
 222:	a1 14       	cp	r10, r1
 224:	b1 04       	cpc	r11, r1
 226:	39 f0       	breq	.+14     	; 0x236 <Endpoint_Write_Stream_LE+0x38>
 228:	f5 01       	movw	r30, r10
 22a:	80 81       	ld	r24, Z
 22c:	91 81       	ldd	r25, Z+1	; 0x01
 22e:	c8 1b       	sub	r28, r24
 230:	d9 0b       	sbc	r29, r25
 232:	e8 0e       	add	r14, r24
 234:	f9 1e       	adc	r15, r25
 236:	20 97       	sbiw	r28, 0x00	; 0
 238:	79 f1       	breq	.+94     	; 0x298 <Endpoint_Write_Stream_LE+0x9a>
 23a:	00 e0       	ldi	r16, 0x00	; 0
 23c:	10 e0       	ldi	r17, 0x00	; 0
 23e:	0f 2e       	mov	r0, r31
 240:	f8 ee       	ldi	r31, 0xE8	; 232
 242:	8f 2e       	mov	r8, r31
 244:	91 2c       	mov	r9, r1
 246:	f0 2d       	mov	r31, r0
 248:	0f 2e       	mov	r0, r31
 24a:	f1 ef       	ldi	r31, 0xF1	; 241
 24c:	cf 2e       	mov	r12, r31
 24e:	d1 2c       	mov	r13, r1
 250:	f0 2d       	mov	r31, r0
 252:	f4 01       	movw	r30, r8
 254:	80 81       	ld	r24, Z
 256:	85 fd       	sbrc	r24, 5
 258:	14 c0       	rjmp	.+40     	; 0x282 <Endpoint_Write_Stream_LE+0x84>
 25a:	80 81       	ld	r24, Z
 25c:	8e 77       	andi	r24, 0x7E	; 126
 25e:	80 83       	st	Z, r24
 260:	f4 d4       	rcall	.+2536   	; 0xc4a <USB_USBTask>
 262:	a1 14       	cp	r10, r1
 264:	b1 04       	cpc	r11, r1
 266:	49 f0       	breq	.+18     	; 0x27a <Endpoint_Write_Stream_LE+0x7c>
 268:	f5 01       	movw	r30, r10
 26a:	80 81       	ld	r24, Z
 26c:	91 81       	ldd	r25, Z+1	; 0x01
 26e:	08 0f       	add	r16, r24
 270:	19 1f       	adc	r17, r25
 272:	11 83       	std	Z+1, r17	; 0x01
 274:	00 83       	st	Z, r16
 276:	85 e0       	ldi	r24, 0x05	; 5
 278:	12 c0       	rjmp	.+36     	; 0x29e <Endpoint_Write_Stream_LE+0xa0>
 27a:	24 d2       	rcall	.+1096   	; 0x6c4 <Endpoint_WaitUntilReady>
 27c:	88 23       	and	r24, r24
 27e:	49 f0       	breq	.+18     	; 0x292 <Endpoint_Write_Stream_LE+0x94>
 280:	0e c0       	rjmp	.+28     	; 0x29e <Endpoint_Write_Stream_LE+0xa0>
 282:	f7 01       	movw	r30, r14
 284:	81 91       	ld	r24, Z+
 286:	7f 01       	movw	r14, r30
 288:	f6 01       	movw	r30, r12
 28a:	80 83       	st	Z, r24
 28c:	21 97       	sbiw	r28, 0x01	; 1
 28e:	0f 5f       	subi	r16, 0xFF	; 255
 290:	1f 4f       	sbci	r17, 0xFF	; 255
 292:	20 97       	sbiw	r28, 0x00	; 0
 294:	f1 f6       	brne	.-68     	; 0x252 <Endpoint_Write_Stream_LE+0x54>
 296:	02 c0       	rjmp	.+4      	; 0x29c <Endpoint_Write_Stream_LE+0x9e>
 298:	80 e0       	ldi	r24, 0x00	; 0
 29a:	01 c0       	rjmp	.+2      	; 0x29e <Endpoint_Write_Stream_LE+0xa0>
 29c:	80 e0       	ldi	r24, 0x00	; 0
 29e:	df 91       	pop	r29
 2a0:	cf 91       	pop	r28
 2a2:	1f 91       	pop	r17
 2a4:	0f 91       	pop	r16
 2a6:	ff 90       	pop	r15
 2a8:	ef 90       	pop	r14
 2aa:	df 90       	pop	r13
 2ac:	cf 90       	pop	r12
 2ae:	bf 90       	pop	r11
 2b0:	af 90       	pop	r10
 2b2:	9f 90       	pop	r9
 2b4:	8f 90       	pop	r8
 2b6:	08 95       	ret

000002b8 <Endpoint_Write_Control_Stream_LE>:
 2b8:	df 92       	push	r13
 2ba:	ef 92       	push	r14
 2bc:	ff 92       	push	r15
 2be:	0f 93       	push	r16
 2c0:	1f 93       	push	r17
 2c2:	cf 93       	push	r28
 2c4:	df 93       	push	r29
 2c6:	20 91 1a 01 	lds	r18, 0x011A
 2ca:	30 91 1b 01 	lds	r19, 0x011B
 2ce:	26 17       	cp	r18, r22
 2d0:	37 07       	cpc	r19, r23
 2d2:	58 f0       	brcs	.+22     	; 0x2ea <Endpoint_Write_Control_Stream_LE+0x32>
 2d4:	61 15       	cp	r22, r1
 2d6:	71 05       	cpc	r23, r1
 2d8:	39 f4       	brne	.+14     	; 0x2e8 <Endpoint_Write_Control_Stream_LE+0x30>
 2da:	e8 ee       	ldi	r30, 0xE8	; 232
 2dc:	f0 e0       	ldi	r31, 0x00	; 0
 2de:	20 81       	ld	r18, Z
 2e0:	2e 77       	andi	r18, 0x7E	; 126
 2e2:	20 83       	st	Z, r18
 2e4:	9b 01       	movw	r18, r22
 2e6:	01 c0       	rjmp	.+2      	; 0x2ea <Endpoint_Write_Control_Stream_LE+0x32>
 2e8:	9b 01       	movw	r18, r22
 2ea:	a0 e0       	ldi	r26, 0x00	; 0
 2ec:	e8 ee       	ldi	r30, 0xE8	; 232
 2ee:	f0 e0       	ldi	r31, 0x00	; 0
 2f0:	03 ef       	ldi	r16, 0xF3	; 243
 2f2:	10 e0       	ldi	r17, 0x00	; 0
 2f4:	62 ef       	ldi	r22, 0xF2	; 242
 2f6:	70 e0       	ldi	r23, 0x00	; 0
 2f8:	c1 ef       	ldi	r28, 0xF1	; 241
 2fa:	d0 e0       	ldi	r29, 0x00	; 0
 2fc:	ff 24       	eor	r15, r15
 2fe:	f3 94       	inc	r15
 300:	e1 2c       	mov	r14, r1
 302:	38 c0       	rjmp	.+112    	; 0x374 <Endpoint_Write_Control_Stream_LE+0xbc>
 304:	40 91 13 01 	lds	r20, 0x0113
 308:	44 23       	and	r20, r20
 30a:	09 f4       	brne	.+2      	; 0x30e <Endpoint_Write_Control_Stream_LE+0x56>
 30c:	44 c0       	rjmp	.+136    	; 0x396 <Endpoint_Write_Control_Stream_LE+0xde>
 30e:	45 30       	cpi	r20, 0x05	; 5
 310:	09 f4       	brne	.+2      	; 0x314 <Endpoint_Write_Control_Stream_LE+0x5c>
 312:	43 c0       	rjmp	.+134    	; 0x39a <Endpoint_Write_Control_Stream_LE+0xe2>
 314:	40 81       	ld	r20, Z
 316:	43 fd       	sbrc	r20, 3
 318:	42 c0       	rjmp	.+132    	; 0x39e <Endpoint_Write_Control_Stream_LE+0xe6>
 31a:	40 81       	ld	r20, Z
 31c:	42 ff       	sbrs	r20, 2
 31e:	03 c0       	rjmp	.+6      	; 0x326 <Endpoint_Write_Control_Stream_LE+0x6e>
 320:	e8 ee       	ldi	r30, 0xE8	; 232
 322:	f0 e0       	ldi	r31, 0x00	; 0
 324:	33 c0       	rjmp	.+102    	; 0x38c <Endpoint_Write_Control_Stream_LE+0xd4>
 326:	40 81       	ld	r20, Z
 328:	40 ff       	sbrs	r20, 0
 32a:	24 c0       	rjmp	.+72     	; 0x374 <Endpoint_Write_Control_Stream_LE+0xbc>
 32c:	d8 01       	movw	r26, r16
 32e:	dc 90       	ld	r13, X
 330:	db 01       	movw	r26, r22
 332:	4c 91       	ld	r20, X
 334:	50 e0       	ldi	r21, 0x00	; 0
 336:	5d 29       	or	r21, r13
 338:	21 15       	cp	r18, r1
 33a:	31 05       	cpc	r19, r1
 33c:	99 f0       	breq	.+38     	; 0x364 <Endpoint_Write_Control_Stream_LE+0xac>
 33e:	48 30       	cpi	r20, 0x08	; 8
 340:	51 05       	cpc	r21, r1
 342:	80 f4       	brcc	.+32     	; 0x364 <Endpoint_Write_Control_Stream_LE+0xac>
 344:	a8 2f       	mov	r26, r24
 346:	b9 2f       	mov	r27, r25
 348:	8d 91       	ld	r24, X+
 34a:	88 83       	st	Y, r24
 34c:	8a 2f       	mov	r24, r26
 34e:	9b 2f       	mov	r25, r27
 350:	21 50       	subi	r18, 0x01	; 1
 352:	31 09       	sbc	r19, r1
 354:	4f 5f       	subi	r20, 0xFF	; 255
 356:	5f 4f       	sbci	r21, 0xFF	; 255
 358:	21 15       	cp	r18, r1
 35a:	31 05       	cpc	r19, r1
 35c:	19 f0       	breq	.+6      	; 0x364 <Endpoint_Write_Control_Stream_LE+0xac>
 35e:	48 30       	cpi	r20, 0x08	; 8
 360:	51 05       	cpc	r21, r1
 362:	91 f7       	brne	.-28     	; 0x348 <Endpoint_Write_Control_Stream_LE+0x90>
 364:	af 2d       	mov	r26, r15
 366:	48 30       	cpi	r20, 0x08	; 8
 368:	51 05       	cpc	r21, r1
 36a:	09 f0       	breq	.+2      	; 0x36e <Endpoint_Write_Control_Stream_LE+0xb6>
 36c:	ae 2d       	mov	r26, r14
 36e:	40 81       	ld	r20, Z
 370:	4e 77       	andi	r20, 0x7E	; 126
 372:	40 83       	st	Z, r20
 374:	21 15       	cp	r18, r1
 376:	31 05       	cpc	r19, r1
 378:	29 f6       	brne	.-118    	; 0x304 <Endpoint_Write_Control_Stream_LE+0x4c>
 37a:	a1 11       	cpse	r26, r1
 37c:	c3 cf       	rjmp	.-122    	; 0x304 <Endpoint_Write_Control_Stream_LE+0x4c>
 37e:	d0 cf       	rjmp	.-96     	; 0x320 <Endpoint_Write_Control_Stream_LE+0x68>
 380:	80 91 13 01 	lds	r24, 0x0113
 384:	88 23       	and	r24, r24
 386:	69 f0       	breq	.+26     	; 0x3a2 <Endpoint_Write_Control_Stream_LE+0xea>
 388:	85 30       	cpi	r24, 0x05	; 5
 38a:	69 f0       	breq	.+26     	; 0x3a6 <Endpoint_Write_Control_Stream_LE+0xee>
 38c:	80 81       	ld	r24, Z
 38e:	82 ff       	sbrs	r24, 2
 390:	f7 cf       	rjmp	.-18     	; 0x380 <Endpoint_Write_Control_Stream_LE+0xc8>
 392:	80 e0       	ldi	r24, 0x00	; 0
 394:	09 c0       	rjmp	.+18     	; 0x3a8 <Endpoint_Write_Control_Stream_LE+0xf0>
 396:	82 e0       	ldi	r24, 0x02	; 2
 398:	07 c0       	rjmp	.+14     	; 0x3a8 <Endpoint_Write_Control_Stream_LE+0xf0>
 39a:	83 e0       	ldi	r24, 0x03	; 3
 39c:	05 c0       	rjmp	.+10     	; 0x3a8 <Endpoint_Write_Control_Stream_LE+0xf0>
 39e:	81 e0       	ldi	r24, 0x01	; 1
 3a0:	03 c0       	rjmp	.+6      	; 0x3a8 <Endpoint_Write_Control_Stream_LE+0xf0>
 3a2:	82 e0       	ldi	r24, 0x02	; 2
 3a4:	01 c0       	rjmp	.+2      	; 0x3a8 <Endpoint_Write_Control_Stream_LE+0xf0>
 3a6:	83 e0       	ldi	r24, 0x03	; 3
 3a8:	df 91       	pop	r29
 3aa:	cf 91       	pop	r28
 3ac:	1f 91       	pop	r17
 3ae:	0f 91       	pop	r16
 3b0:	ff 90       	pop	r15
 3b2:	ef 90       	pop	r14
 3b4:	df 90       	pop	r13
 3b6:	08 95       	ret

000003b8 <Endpoint_Read_Control_Stream_LE>:
 3b8:	cf 92       	push	r12
 3ba:	df 92       	push	r13
 3bc:	ff 92       	push	r15
 3be:	0f 93       	push	r16
 3c0:	1f 93       	push	r17
 3c2:	cf 93       	push	r28
 3c4:	df 93       	push	r29
 3c6:	61 15       	cp	r22, r1
 3c8:	71 05       	cpc	r23, r1
 3ca:	29 f4       	brne	.+10     	; 0x3d6 <Endpoint_Read_Control_Stream_LE+0x1e>
 3cc:	e8 ee       	ldi	r30, 0xE8	; 232
 3ce:	f0 e0       	ldi	r31, 0x00	; 0
 3d0:	20 81       	ld	r18, Z
 3d2:	2b 77       	andi	r18, 0x7B	; 123
 3d4:	20 83       	st	Z, r18
 3d6:	e8 ee       	ldi	r30, 0xE8	; 232
 3d8:	f0 e0       	ldi	r31, 0x00	; 0
 3da:	43 ef       	ldi	r20, 0xF3	; 243
 3dc:	50 e0       	ldi	r21, 0x00	; 0
 3de:	0f 2e       	mov	r0, r31
 3e0:	f2 ef       	ldi	r31, 0xF2	; 242
 3e2:	cf 2e       	mov	r12, r31
 3e4:	d1 2c       	mov	r13, r1
 3e6:	f0 2d       	mov	r31, r0
 3e8:	01 ef       	ldi	r16, 0xF1	; 241
 3ea:	10 e0       	ldi	r17, 0x00	; 0
 3ec:	22 c0       	rjmp	.+68     	; 0x432 <Endpoint_Read_Control_Stream_LE+0x7a>
 3ee:	20 91 13 01 	lds	r18, 0x0113
 3f2:	22 23       	and	r18, r18
 3f4:	e1 f1       	breq	.+120    	; 0x46e <Endpoint_Read_Control_Stream_LE+0xb6>
 3f6:	25 30       	cpi	r18, 0x05	; 5
 3f8:	e1 f1       	breq	.+120    	; 0x472 <Endpoint_Read_Control_Stream_LE+0xba>
 3fa:	20 81       	ld	r18, Z
 3fc:	23 fd       	sbrc	r18, 3
 3fe:	3b c0       	rjmp	.+118    	; 0x476 <Endpoint_Read_Control_Stream_LE+0xbe>
 400:	20 81       	ld	r18, Z
 402:	22 ff       	sbrs	r18, 2
 404:	f4 cf       	rjmp	.-24     	; 0x3ee <Endpoint_Read_Control_Stream_LE+0x36>
 406:	43 c0       	rjmp	.+134    	; 0x48e <Endpoint_Read_Control_Stream_LE+0xd6>
 408:	e8 01       	movw	r28, r16
 40a:	88 81       	ld	r24, Y
 40c:	8d 93       	st	X+, r24
 40e:	8a 2f       	mov	r24, r26
 410:	9b 2f       	mov	r25, r27
 412:	61 50       	subi	r22, 0x01	; 1
 414:	71 09       	sbc	r23, r1
 416:	61 15       	cp	r22, r1
 418:	71 05       	cpc	r23, r1
 41a:	41 f0       	breq	.+16     	; 0x42c <Endpoint_Read_Control_Stream_LE+0x74>
 41c:	ea 01       	movw	r28, r20
 41e:	f8 80       	ld	r15, Y
 420:	e6 01       	movw	r28, r12
 422:	28 81       	ld	r18, Y
 424:	30 e0       	ldi	r19, 0x00	; 0
 426:	3f 29       	or	r19, r15
 428:	23 2b       	or	r18, r19
 42a:	71 f7       	brne	.-36     	; 0x408 <Endpoint_Read_Control_Stream_LE+0x50>
 42c:	20 81       	ld	r18, Z
 42e:	2b 77       	andi	r18, 0x7B	; 123
 430:	20 83       	st	Z, r18
 432:	61 15       	cp	r22, r1
 434:	71 05       	cpc	r23, r1
 436:	19 f4       	brne	.+6      	; 0x43e <Endpoint_Read_Control_Stream_LE+0x86>
 438:	e8 ee       	ldi	r30, 0xE8	; 232
 43a:	f0 e0       	ldi	r31, 0x00	; 0
 43c:	13 c0       	rjmp	.+38     	; 0x464 <Endpoint_Read_Control_Stream_LE+0xac>
 43e:	20 91 13 01 	lds	r18, 0x0113
 442:	22 23       	and	r18, r18
 444:	d1 f0       	breq	.+52     	; 0x47a <Endpoint_Read_Control_Stream_LE+0xc2>
 446:	25 30       	cpi	r18, 0x05	; 5
 448:	d1 f0       	breq	.+52     	; 0x47e <Endpoint_Read_Control_Stream_LE+0xc6>
 44a:	20 81       	ld	r18, Z
 44c:	23 fd       	sbrc	r18, 3
 44e:	19 c0       	rjmp	.+50     	; 0x482 <Endpoint_Read_Control_Stream_LE+0xca>
 450:	20 81       	ld	r18, Z
 452:	22 fd       	sbrc	r18, 2
 454:	1c c0       	rjmp	.+56     	; 0x48e <Endpoint_Read_Control_Stream_LE+0xd6>
 456:	cb cf       	rjmp	.-106    	; 0x3ee <Endpoint_Read_Control_Stream_LE+0x36>
 458:	80 91 13 01 	lds	r24, 0x0113
 45c:	88 23       	and	r24, r24
 45e:	99 f0       	breq	.+38     	; 0x486 <Endpoint_Read_Control_Stream_LE+0xce>
 460:	85 30       	cpi	r24, 0x05	; 5
 462:	99 f0       	breq	.+38     	; 0x48a <Endpoint_Read_Control_Stream_LE+0xd2>
 464:	80 81       	ld	r24, Z
 466:	80 ff       	sbrs	r24, 0
 468:	f7 cf       	rjmp	.-18     	; 0x458 <Endpoint_Read_Control_Stream_LE+0xa0>
 46a:	80 e0       	ldi	r24, 0x00	; 0
 46c:	1b c0       	rjmp	.+54     	; 0x4a4 <Endpoint_Read_Control_Stream_LE+0xec>
 46e:	82 e0       	ldi	r24, 0x02	; 2
 470:	19 c0       	rjmp	.+50     	; 0x4a4 <Endpoint_Read_Control_Stream_LE+0xec>
 472:	83 e0       	ldi	r24, 0x03	; 3
 474:	17 c0       	rjmp	.+46     	; 0x4a4 <Endpoint_Read_Control_Stream_LE+0xec>
 476:	81 e0       	ldi	r24, 0x01	; 1
 478:	15 c0       	rjmp	.+42     	; 0x4a4 <Endpoint_Read_Control_Stream_LE+0xec>
 47a:	82 e0       	ldi	r24, 0x02	; 2
 47c:	13 c0       	rjmp	.+38     	; 0x4a4 <Endpoint_Read_Control_Stream_LE+0xec>
 47e:	83 e0       	ldi	r24, 0x03	; 3
 480:	11 c0       	rjmp	.+34     	; 0x4a4 <Endpoint_Read_Control_Stream_LE+0xec>
 482:	81 e0       	ldi	r24, 0x01	; 1
 484:	0f c0       	rjmp	.+30     	; 0x4a4 <Endpoint_Read_Control_Stream_LE+0xec>
 486:	82 e0       	ldi	r24, 0x02	; 2
 488:	0d c0       	rjmp	.+26     	; 0x4a4 <Endpoint_Read_Control_Stream_LE+0xec>
 48a:	83 e0       	ldi	r24, 0x03	; 3
 48c:	0b c0       	rjmp	.+22     	; 0x4a4 <Endpoint_Read_Control_Stream_LE+0xec>
 48e:	ea 01       	movw	r28, r20
 490:	a8 81       	ld	r26, Y
 492:	e6 01       	movw	r28, r12
 494:	28 81       	ld	r18, Y
 496:	30 e0       	ldi	r19, 0x00	; 0
 498:	3a 2b       	or	r19, r26
 49a:	23 2b       	or	r18, r19
 49c:	39 f2       	breq	.-114    	; 0x42c <Endpoint_Read_Control_Stream_LE+0x74>
 49e:	a8 2f       	mov	r26, r24
 4a0:	b9 2f       	mov	r27, r25
 4a2:	b2 cf       	rjmp	.-156    	; 0x408 <Endpoint_Read_Control_Stream_LE+0x50>
 4a4:	df 91       	pop	r29
 4a6:	cf 91       	pop	r28
 4a8:	1f 91       	pop	r17
 4aa:	0f 91       	pop	r16
 4ac:	ff 90       	pop	r15
 4ae:	df 90       	pop	r13
 4b0:	cf 90       	pop	r12
 4b2:	08 95       	ret

000004b4 <Endpoint_Write_Control_PStream_LE>:

#if defined(TEMPLATE_FUNC_NAME)

uint8_t TEMPLATE_FUNC_NAME (const void* const Buffer,
                            uint16_t Length)
{
 4b4:	cf 92       	push	r12
 4b6:	df 92       	push	r13
 4b8:	ff 92       	push	r15
 4ba:	0f 93       	push	r16
 4bc:	1f 93       	push	r17
 4be:	cf 93       	push	r28
 4c0:	df 93       	push	r29
	uint8_t* DataStream     = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length));
	bool     LastPacketFull = false;

	if (Length > USB_ControlRequest.wLength)
 4c2:	20 91 1a 01 	lds	r18, 0x011A
 4c6:	30 91 1b 01 	lds	r19, 0x011B
 4ca:	26 17       	cp	r18, r22
 4cc:	37 07       	cpc	r19, r23
 4ce:	58 f0       	brcs	.+22     	; 0x4e6 <Endpoint_Write_Control_PStream_LE+0x32>
	  Length = USB_ControlRequest.wLength;
	else if (!(Length))
 4d0:	61 15       	cp	r22, r1
 4d2:	71 05       	cpc	r23, r1
 4d4:	39 f4       	brne	.+14     	; 0x4e4 <Endpoint_Write_Control_PStream_LE+0x30>
			 */
			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));
 4d6:	e8 ee       	ldi	r30, 0xE8	; 232
 4d8:	f0 e0       	ldi	r31, 0x00	; 0
 4da:	20 81       	ld	r18, Z
 4dc:	2e 77       	andi	r18, 0x7E	; 126
 4de:	20 83       	st	Z, r18
 4e0:	9b 01       	movw	r18, r22
 4e2:	01 c0       	rjmp	.+2      	; 0x4e6 <Endpoint_Write_Control_PStream_LE+0x32>
 4e4:	9b 01       	movw	r18, r22
 4e6:	e8 2f       	mov	r30, r24
 4e8:	f9 2f       	mov	r31, r25
 4ea:	10 e0       	ldi	r17, 0x00	; 0
			 *  \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);
 4ec:	a8 ee       	ldi	r26, 0xE8	; 232
 4ee:	b0 e0       	ldi	r27, 0x00	; 0
			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);
 4f0:	63 ef       	ldi	r22, 0xF3	; 243
 4f2:	70 e0       	ldi	r23, 0x00	; 0
 4f4:	42 ef       	ldi	r20, 0xF2	; 242
 4f6:	50 e0       	ldi	r21, 0x00	; 0
			 *  \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;
 4f8:	0f 2e       	mov	r0, r31
 4fa:	f1 ef       	ldi	r31, 0xF1	; 241
 4fc:	cf 2e       	mov	r12, r31
 4fe:	d1 2c       	mov	r13, r1
 500:	f0 2d       	mov	r31, r0
				TEMPLATE_BUFFER_MOVE(DataStream, 1);
				Length--;
				BytesInEndpoint++;
			}

			LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
 502:	01 e0       	ldi	r16, 0x01	; 1
 504:	f1 2c       	mov	r15, r1
 506:	34 c0       	rjmp	.+104    	; 0x570 <Endpoint_Write_Control_PStream_LE+0xbc>
	else if (!(Length))
	  Endpoint_ClearIN();

	while (Length || LastPacketFull)
	{
		uint8_t USB_DeviceState_LCL = USB_DeviceState;
 508:	80 91 13 01 	lds	r24, 0x0113

		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
 50c:	88 23       	and	r24, r24
 50e:	09 f4       	brne	.+2      	; 0x512 <Endpoint_Write_Control_PStream_LE+0x5e>
 510:	40 c0       	rjmp	.+128    	; 0x592 <Endpoint_Write_Control_PStream_LE+0xde>
		  return ENDPOINT_RWCSTREAM_DeviceDisconnected;
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
 512:	85 30       	cpi	r24, 0x05	; 5
 514:	09 f4       	brne	.+2      	; 0x518 <Endpoint_Write_Control_PStream_LE+0x64>
 516:	3f c0       	rjmp	.+126    	; 0x596 <Endpoint_Write_Control_PStream_LE+0xe2>
			 *  \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);
 518:	8c 91       	ld	r24, X
		  return ENDPOINT_RWCSTREAM_BusSuspended;
		else if (Endpoint_IsSETUPReceived())
 51a:	83 fd       	sbrc	r24, 3
 51c:	3e c0       	rjmp	.+124    	; 0x59a <Endpoint_Write_Control_PStream_LE+0xe6>
			 *  \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);
 51e:	8c 91       	ld	r24, X
		  return ENDPOINT_RWCSTREAM_HostAborted;
		else if (Endpoint_IsOUTReceived())
 520:	82 ff       	sbrs	r24, 2
 522:	03 c0       	rjmp	.+6      	; 0x52a <Endpoint_Write_Control_PStream_LE+0x76>
 524:	e8 ee       	ldi	r30, 0xE8	; 232
 526:	f0 e0       	ldi	r31, 0x00	; 0
 528:	2f c0       	rjmp	.+94     	; 0x588 <Endpoint_Write_Control_PStream_LE+0xd4>
			 *  \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);
 52a:	8c 91       	ld	r24, X
		  break;

		if (Endpoint_IsINReady())
 52c:	80 ff       	sbrs	r24, 0
 52e:	20 c0       	rjmp	.+64     	; 0x570 <Endpoint_Write_Control_PStream_LE+0xbc>
			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);
 530:	eb 01       	movw	r28, r22
 532:	18 81       	ld	r17, Y
 534:	ea 01       	movw	r28, r20
 536:	88 81       	ld	r24, Y
 538:	90 e0       	ldi	r25, 0x00	; 0
 53a:	91 2b       	or	r25, r17
		{
			uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();

			while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
 53c:	21 15       	cp	r18, r1
 53e:	31 05       	cpc	r19, r1
 540:	81 f0       	breq	.+32     	; 0x562 <Endpoint_Write_Control_PStream_LE+0xae>
 542:	88 30       	cpi	r24, 0x08	; 8
 544:	91 05       	cpc	r25, r1
 546:	68 f4       	brcc	.+26     	; 0x562 <Endpoint_Write_Control_PStream_LE+0xae>
			{
				TEMPLATE_TRANSFER_BYTE(DataStream);
 548:	14 91       	lpm	r17, 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;
 54a:	e6 01       	movw	r28, r12
 54c:	18 83       	st	Y, r17
				TEMPLATE_BUFFER_MOVE(DataStream, 1);
 54e:	31 96       	adiw	r30, 0x01	; 1
				Length--;
 550:	21 50       	subi	r18, 0x01	; 1
 552:	31 09       	sbc	r19, r1
				BytesInEndpoint++;
 554:	01 96       	adiw	r24, 0x01	; 1

		if (Endpoint_IsINReady())
		{
			uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();

			while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
 556:	21 15       	cp	r18, r1
 558:	31 05       	cpc	r19, r1
 55a:	19 f0       	breq	.+6      	; 0x562 <Endpoint_Write_Control_PStream_LE+0xae>
 55c:	88 30       	cpi	r24, 0x08	; 8
 55e:	91 05       	cpc	r25, r1
 560:	99 f7       	brne	.-26     	; 0x548 <Endpoint_Write_Control_PStream_LE+0x94>
				TEMPLATE_BUFFER_MOVE(DataStream, 1);
				Length--;
				BytesInEndpoint++;
			}

			LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
 562:	10 2f       	mov	r17, r16
 564:	08 97       	sbiw	r24, 0x08	; 8
 566:	09 f0       	breq	.+2      	; 0x56a <Endpoint_Write_Control_PStream_LE+0xb6>
 568:	1f 2d       	mov	r17, r15
			 */
			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));
 56a:	8c 91       	ld	r24, X
 56c:	8e 77       	andi	r24, 0x7E	; 126
 56e:	8c 93       	st	X, r24
	if (Length > USB_ControlRequest.wLength)
	  Length = USB_ControlRequest.wLength;
	else if (!(Length))
	  Endpoint_ClearIN();

	while (Length || LastPacketFull)
 570:	21 15       	cp	r18, r1
 572:	31 05       	cpc	r19, r1
 574:	49 f6       	brne	.-110    	; 0x508 <Endpoint_Write_Control_PStream_LE+0x54>
 576:	11 11       	cpse	r17, r1
 578:	c7 cf       	rjmp	.-114    	; 0x508 <Endpoint_Write_Control_PStream_LE+0x54>
 57a:	d4 cf       	rjmp	.-88     	; 0x524 <Endpoint_Write_Control_PStream_LE+0x70>
		}
	}

	while (!(Endpoint_IsOUTReceived()))
	{
		uint8_t USB_DeviceState_LCL = USB_DeviceState;
 57c:	80 91 13 01 	lds	r24, 0x0113

		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
 580:	88 23       	and	r24, r24
 582:	69 f0       	breq	.+26     	; 0x59e <Endpoint_Write_Control_PStream_LE+0xea>
		  return ENDPOINT_RWCSTREAM_DeviceDisconnected;
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
 584:	85 30       	cpi	r24, 0x05	; 5
 586:	69 f0       	breq	.+26     	; 0x5a2 <Endpoint_Write_Control_PStream_LE+0xee>
			 *  \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);
 588:	80 81       	ld	r24, Z
			LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
			Endpoint_ClearIN();
		}
	}

	while (!(Endpoint_IsOUTReceived()))
 58a:	82 ff       	sbrs	r24, 2
 58c:	f7 cf       	rjmp	.-18     	; 0x57c <Endpoint_Write_Control_PStream_LE+0xc8>
		  return ENDPOINT_RWCSTREAM_DeviceDisconnected;
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
		  return ENDPOINT_RWCSTREAM_BusSuspended;
	}

	return ENDPOINT_RWCSTREAM_NoError;
 58e:	80 e0       	ldi	r24, 0x00	; 0
 590:	09 c0       	rjmp	.+18     	; 0x5a4 <Endpoint_Write_Control_PStream_LE+0xf0>
	while (Length || LastPacketFull)
	{
		uint8_t USB_DeviceState_LCL = USB_DeviceState;

		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
		  return ENDPOINT_RWCSTREAM_DeviceDisconnected;
 592:	82 e0       	ldi	r24, 0x02	; 2
 594:	07 c0       	rjmp	.+14     	; 0x5a4 <Endpoint_Write_Control_PStream_LE+0xf0>
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
		  return ENDPOINT_RWCSTREAM_BusSuspended;
 596:	83 e0       	ldi	r24, 0x03	; 3
 598:	05 c0       	rjmp	.+10     	; 0x5a4 <Endpoint_Write_Control_PStream_LE+0xf0>
		else if (Endpoint_IsSETUPReceived())
		  return ENDPOINT_RWCSTREAM_HostAborted;
 59a:	81 e0       	ldi	r24, 0x01	; 1
 59c:	03 c0       	rjmp	.+6      	; 0x5a4 <Endpoint_Write_Control_PStream_LE+0xf0>
	while (!(Endpoint_IsOUTReceived()))
	{
		uint8_t USB_DeviceState_LCL = USB_DeviceState;

		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
		  return ENDPOINT_RWCSTREAM_DeviceDisconnected;
 59e:	82 e0       	ldi	r24, 0x02	; 2
 5a0:	01 c0       	rjmp	.+2      	; 0x5a4 <Endpoint_Write_Control_PStream_LE+0xf0>
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
		  return ENDPOINT_RWCSTREAM_BusSuspended;
 5a2:	83 e0       	ldi	r24, 0x03	; 3
	}

	return ENDPOINT_RWCSTREAM_NoError;
}
 5a4:	df 91       	pop	r29
 5a6:	cf 91       	pop	r28
 5a8:	1f 91       	pop	r17
 5aa:	0f 91       	pop	r16
 5ac:	ff 90       	pop	r15
 5ae:	df 90       	pop	r13
 5b0:	cf 90       	pop	r12
 5b2:	08 95       	ret

000005b4 <Endpoint_ConfigureEndpoint_Prv>:
		UEIENX  = 0;
		UEINTX  = 0;
		UECFG1X = 0;
		Endpoint_DisableEndpoint();
	}
}
 5b4:	8f 92       	push	r8
 5b6:	9f 92       	push	r9
 5b8:	bf 92       	push	r11
 5ba:	cf 92       	push	r12
 5bc:	df 92       	push	r13
 5be:	ef 92       	push	r14
 5c0:	ff 92       	push	r15
 5c2:	0f 93       	push	r16
 5c4:	1f 93       	push	r17
 5c6:	cf 93       	push	r28
 5c8:	df 93       	push	r29
 5ca:	87 30       	cpi	r24, 0x07	; 7
 5cc:	70 f1       	brcs	.+92     	; 0x62a <Endpoint_ConfigureEndpoint_Prv+0x76>
 5ce:	26 c0       	rjmp	.+76     	; 0x61c <Endpoint_ConfigureEndpoint_Prv+0x68>
 5d0:	59 2f       	mov	r21, r25
 5d2:	5f 70       	andi	r21, 0x0F	; 15
 5d4:	e8 01       	movw	r28, r16
 5d6:	58 83       	st	Y, r21
 5d8:	89 17       	cp	r24, r25
 5da:	31 f0       	breq	.+12     	; 0x5e8 <Endpoint_ConfigureEndpoint_Prv+0x34>
 5dc:	e9 01       	movw	r28, r18
 5de:	d8 80       	ld	r13, Y
 5e0:	50 81       	ld	r21, Z
 5e2:	e4 01       	movw	r28, r8
 5e4:	78 81       	ld	r23, Y
 5e6:	03 c0       	rjmp	.+6      	; 0x5ee <Endpoint_ConfigureEndpoint_Prv+0x3a>
 5e8:	5b 2d       	mov	r21, r11
 5ea:	d6 2e       	mov	r13, r22
 5ec:	7c 2d       	mov	r23, r12
 5ee:	51 ff       	sbrs	r21, 1
 5f0:	12 c0       	rjmp	.+36     	; 0x616 <Endpoint_ConfigureEndpoint_Prv+0x62>
 5f2:	4c 91       	ld	r20, X
 5f4:	4e 7f       	andi	r20, 0xFE	; 254
 5f6:	4c 93       	st	X, r20
 5f8:	40 81       	ld	r20, Z
 5fa:	4d 7f       	andi	r20, 0xFD	; 253
 5fc:	40 83       	st	Z, r20
 5fe:	4c 91       	ld	r20, X
 600:	41 60       	ori	r20, 0x01	; 1
 602:	4c 93       	st	X, r20
 604:	e9 01       	movw	r28, r18
 606:	d8 82       	st	Y, r13
 608:	50 83       	st	Z, r21
 60a:	e4 01       	movw	r28, r8
 60c:	78 83       	st	Y, r23
 60e:	e7 01       	movw	r28, r14
 610:	58 81       	ld	r21, Y
 612:	55 23       	and	r21, r21
 614:	44 f4       	brge	.+16     	; 0x626 <Endpoint_ConfigureEndpoint_Prv+0x72>
 616:	9f 5f       	subi	r25, 0xFF	; 255
 618:	97 30       	cpi	r25, 0x07	; 7
 61a:	d1 f6       	brne	.-76     	; 0x5d0 <Endpoint_ConfigureEndpoint_Prv+0x1c>
 61c:	8f 70       	andi	r24, 0x0F	; 15
 61e:	80 93 e9 00 	sts	0x00E9, r24
 622:	81 e0       	ldi	r24, 0x01	; 1
 624:	1f c0       	rjmp	.+62     	; 0x664 <Endpoint_ConfigureEndpoint_Prv+0xb0>
 626:	80 e0       	ldi	r24, 0x00	; 0
 628:	1d c0       	rjmp	.+58     	; 0x664 <Endpoint_ConfigureEndpoint_Prv+0xb0>
 62a:	98 2f       	mov	r25, r24
 62c:	9f 70       	andi	r25, 0x0F	; 15
 62e:	90 93 e9 00 	sts	0x00E9, r25
 632:	98 2f       	mov	r25, r24
 634:	54 2f       	mov	r21, r20
 636:	d6 2e       	mov	r13, r22
 638:	70 e0       	ldi	r23, 0x00	; 0
 63a:	ab ee       	ldi	r26, 0xEB	; 235
 63c:	b0 e0       	ldi	r27, 0x00	; 0
 63e:	ed ee       	ldi	r30, 0xED	; 237
 640:	f0 e0       	ldi	r31, 0x00	; 0
 642:	2c ee       	ldi	r18, 0xEC	; 236
 644:	30 e0       	ldi	r19, 0x00	; 0
 646:	0f 2e       	mov	r0, r31
 648:	f0 ef       	ldi	r31, 0xF0	; 240
 64a:	8f 2e       	mov	r8, r31
 64c:	91 2c       	mov	r9, r1
 64e:	f0 2d       	mov	r31, r0
 650:	0f 2e       	mov	r0, r31
 652:	fe ee       	ldi	r31, 0xEE	; 238
 654:	ef 2e       	mov	r14, r31
 656:	f1 2c       	mov	r15, r1
 658:	f0 2d       	mov	r31, r0
 65a:	09 ee       	ldi	r16, 0xE9	; 233
 65c:	10 e0       	ldi	r17, 0x00	; 0
 65e:	b4 2e       	mov	r11, r20
 660:	c1 2c       	mov	r12, r1
 662:	c5 cf       	rjmp	.-118    	; 0x5ee <Endpoint_ConfigureEndpoint_Prv+0x3a>
 664:	df 91       	pop	r29
 666:	cf 91       	pop	r28
 668:	1f 91       	pop	r17
 66a:	0f 91       	pop	r16
 66c:	ff 90       	pop	r15
 66e:	ef 90       	pop	r14
 670:	df 90       	pop	r13
 672:	cf 90       	pop	r12
 674:	bf 90       	pop	r11
 676:	9f 90       	pop	r9
 678:	8f 90       	pop	r8
 67a:	08 95       	ret

0000067c <Endpoint_ClearStatusStage>:

void Endpoint_ClearStatusStage(void)
{
	if (USB_ControlRequest.bmRequestType & REQDIR_DEVICETOHOST)
 67c:	80 91 14 01 	lds	r24, 0x0114
 680:	88 23       	and	r24, r24
 682:	1c f0       	brlt	.+6      	; 0x68a <Endpoint_ClearStatusStage+0xe>
			 *  \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);
 684:	e8 ee       	ldi	r30, 0xE8	; 232
 686:	f0 e0       	ldi	r31, 0x00	; 0
 688:	14 c0       	rjmp	.+40     	; 0x6b2 <Endpoint_ClearStatusStage+0x36>
			 *  \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);
 68a:	e8 ee       	ldi	r30, 0xE8	; 232
 68c:	f0 e0       	ldi	r31, 0x00	; 0
 68e:	04 c0       	rjmp	.+8      	; 0x698 <Endpoint_ClearStatusStage+0x1c>
	{
		while (!(Endpoint_IsOUTReceived()))
		{
			if (USB_DeviceState == DEVICE_STATE_Unattached)
 690:	80 91 13 01 	lds	r24, 0x0113
 694:	88 23       	and	r24, r24
 696:	a9 f0       	breq	.+42     	; 0x6c2 <Endpoint_ClearStatusStage+0x46>
 698:	80 81       	ld	r24, Z

void Endpoint_ClearStatusStage(void)
{
	if (USB_ControlRequest.bmRequestType & REQDIR_DEVICETOHOST)
	{
		while (!(Endpoint_IsOUTReceived()))
 69a:	82 ff       	sbrs	r24, 2
 69c:	f9 cf       	rjmp	.-14     	; 0x690 <Endpoint_ClearStatusStage+0x14>
			 */
			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));
 69e:	e8 ee       	ldi	r30, 0xE8	; 232
 6a0:	f0 e0       	ldi	r31, 0x00	; 0
 6a2:	80 81       	ld	r24, Z
 6a4:	8b 77       	andi	r24, 0x7B	; 123
 6a6:	80 83       	st	Z, r24
 6a8:	08 95       	ret
	}
	else
	{
		while (!(Endpoint_IsINReady()))
		{
			if (USB_DeviceState == DEVICE_STATE_Unattached)
 6aa:	80 91 13 01 	lds	r24, 0x0113
 6ae:	88 23       	and	r24, r24
 6b0:	41 f0       	breq	.+16     	; 0x6c2 <Endpoint_ClearStatusStage+0x46>
			 *  \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);
 6b2:	80 81       	ld	r24, Z

		Endpoint_ClearOUT();
	}
	else
	{
		while (!(Endpoint_IsINReady()))
 6b4:	80 ff       	sbrs	r24, 0
 6b6:	f9 cf       	rjmp	.-14     	; 0x6aa <Endpoint_ClearStatusStage+0x2e>
			 */
			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));
 6b8:	e8 ee       	ldi	r30, 0xE8	; 232
 6ba:	f0 e0       	ldi	r31, 0x00	; 0
 6bc:	80 81       	ld	r24, Z
 6be:	8e 77       	andi	r24, 0x7E	; 126
 6c0:	80 83       	st	Z, r24
 6c2:	08 95       	ret

000006c4 <Endpoint_WaitUntilReady>:
	}
}

#if !defined(CONTROL_ONLY_DEVICE)
uint8_t Endpoint_WaitUntilReady(void)
{
 6c4:	0f 93       	push	r16
 6c6:	1f 93       	push	r17
 6c8:	cf 93       	push	r28
 6ca:	df 93       	push	r29
			 *  \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;
 6cc:	20 91 e4 00 	lds	r18, 0x00E4
 6d0:	30 91 e5 00 	lds	r19, 0x00E5
 6d4:	65 e6       	ldi	r22, 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;
 6d6:	ac ee       	ldi	r26, 0xEC	; 236
 6d8:	b0 e0       	ldi	r27, 0x00	; 0
			 *  \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);
 6da:	e8 ee       	ldi	r30, 0xE8	; 232
 6dc:	f0 e0       	ldi	r31, 0x00	; 0
			 *  \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);
 6de:	0b ee       	ldi	r16, 0xEB	; 235
 6e0:	10 e0       	ldi	r17, 0x00	; 0
 6e2:	44 ee       	ldi	r20, 0xE4	; 228
 6e4:	50 e0       	ldi	r21, 0x00	; 0
			 *  \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;
 6e6:	8c 91       	ld	r24, X
 6e8:	80 fd       	sbrc	r24, 0
 6ea:	21 c0       	rjmp	.+66     	; 0x72e <Endpoint_WaitUntilReady+0x6a>
 6ec:	24 c0       	rjmp	.+72     	; 0x736 <Endpoint_WaitUntilReady+0x72>
		{
			if (Endpoint_IsOUTReceived())
			  return ENDPOINT_READYWAIT_NoError;
		}

		uint8_t USB_DeviceState_LCL = USB_DeviceState;
 6ee:	80 91 13 01 	lds	r24, 0x0113

		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
 6f2:	88 23       	and	r24, r24
 6f4:	81 f0       	breq	.+32     	; 0x716 <Endpoint_WaitUntilReady+0x52>
		  return ENDPOINT_READYWAIT_DeviceDisconnected;
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
 6f6:	85 30       	cpi	r24, 0x05	; 5
 6f8:	81 f0       	breq	.+32     	; 0x71a <Endpoint_WaitUntilReady+0x56>
			 *  \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);
 6fa:	e8 01       	movw	r28, r16
 6fc:	88 81       	ld	r24, Y
		  return ENDPOINT_READYWAIT_BusSuspended;
		else if (Endpoint_IsStalled())
 6fe:	85 fd       	sbrc	r24, 5
 700:	0e c0       	rjmp	.+28     	; 0x71e <Endpoint_WaitUntilReady+0x5a>
 702:	ea 01       	movw	r28, r20
 704:	88 81       	ld	r24, Y
 706:	99 81       	ldd	r25, Y+1	; 0x01
		  return ENDPOINT_READYWAIT_EndpointStalled;

		uint16_t CurrentFrameNumber = USB_Device_GetFrameNumber();

		if (CurrentFrameNumber != PreviousFrameNumber)
 708:	28 17       	cp	r18, r24
 70a:	39 07       	cpc	r19, r25
 70c:	61 f3       	breq	.-40     	; 0x6e6 <Endpoint_WaitUntilReady+0x22>
 70e:	61 50       	subi	r22, 0x01	; 1
		{
			PreviousFrameNumber = CurrentFrameNumber;

			if (!(TimeoutMSRem--))
 710:	41 f0       	breq	.+16     	; 0x722 <Endpoint_WaitUntilReady+0x5e>
 712:	9c 01       	movw	r18, r24
 714:	e8 cf       	rjmp	.-48     	; 0x6e6 <Endpoint_WaitUntilReady+0x22>
		}

		uint8_t USB_DeviceState_LCL = USB_DeviceState;

		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
		  return ENDPOINT_READYWAIT_DeviceDisconnected;
 716:	82 e0       	ldi	r24, 0x02	; 2
 718:	12 c0       	rjmp	.+36     	; 0x73e <Endpoint_WaitUntilReady+0x7a>
		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
		  return ENDPOINT_READYWAIT_BusSuspended;
 71a:	83 e0       	ldi	r24, 0x03	; 3
 71c:	10 c0       	rjmp	.+32     	; 0x73e <Endpoint_WaitUntilReady+0x7a>
		else if (Endpoint_IsStalled())
		  return ENDPOINT_READYWAIT_EndpointStalled;
 71e:	81 e0       	ldi	r24, 0x01	; 1
 720:	0e c0       	rjmp	.+28     	; 0x73e <Endpoint_WaitUntilReady+0x7a>
		if (CurrentFrameNumber != PreviousFrameNumber)
		{
			PreviousFrameNumber = CurrentFrameNumber;

			if (!(TimeoutMSRem--))
			  return ENDPOINT_READYWAIT_Timeout;
 722:	84 e0       	ldi	r24, 0x04	; 4
 724:	0c c0       	rjmp	.+24     	; 0x73e <Endpoint_WaitUntilReady+0x7a>
	for (;;)
	{
		if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
		{
			if (Endpoint_IsINReady())
			  return ENDPOINT_READYWAIT_NoError;
 726:	80 e0       	ldi	r24, 0x00	; 0
 728:	0a c0       	rjmp	.+20     	; 0x73e <Endpoint_WaitUntilReady+0x7a>
		}
		else
		{
			if (Endpoint_IsOUTReceived())
			  return ENDPOINT_READYWAIT_NoError;
 72a:	80 e0       	ldi	r24, 0x00	; 0
 72c:	08 c0       	rjmp	.+16     	; 0x73e <Endpoint_WaitUntilReady+0x7a>
			 *  \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);
 72e:	80 81       	ld	r24, Z

	for (;;)
	{
		if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
		{
			if (Endpoint_IsINReady())
 730:	80 ff       	sbrs	r24, 0
 732:	dd cf       	rjmp	.-70     	; 0x6ee <Endpoint_WaitUntilReady+0x2a>
 734:	f8 cf       	rjmp	.-16     	; 0x726 <Endpoint_WaitUntilReady+0x62>
			 *  \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);
 736:	80 81       	ld	r24, Z
			  return ENDPOINT_READYWAIT_NoError;
		}
		else
		{
			if (Endpoint_IsOUTReceived())
 738:	82 ff       	sbrs	r24, 2
 73a:	d9 cf       	rjmp	.-78     	; 0x6ee <Endpoint_WaitUntilReady+0x2a>
 73c:	f6 cf       	rjmp	.-20     	; 0x72a <Endpoint_WaitUntilReady+0x66>

			if (!(TimeoutMSRem--))
			  return ENDPOINT_READYWAIT_Timeout;
		}
	}
}
 73e:	df 91       	pop	r29
 740:	cf 91       	pop	r28
 742:	1f 91       	pop	r17
 744:	0f 91       	pop	r16
 746:	08 95       	ret

00000748 <USB_ResetInterface>:

	USB_IsInitialized = false;
}

void USB_ResetInterface(void)
{
 748:	0f 93       	push	r16
 74a:	1f 93       	push	r17
 74c:	cf 93       	push	r28
 74e:	df 93       	push	r29
	#if defined(USB_CAN_BE_BOTH)
	bool UIDModeSelectEnabled = ((UHWCON & (1 << UIDE)) != 0);
	#endif

	USB_INT_DisableAllInterrupts();
 750:	4c d0       	rcall	.+152    	; 0x7ea <USB_INT_DisableAllInterrupts>
	USB_INT_ClearAllInterrupts();
 752:	53 d0       	rcall	.+166    	; 0x7fa <USB_INT_ClearAllInterrupts>
			}

			static inline void USB_Controller_Reset(void) ATTR_ALWAYS_INLINE;
			static inline void USB_Controller_Reset(void)
			{
				USBCON &= ~(1 << USBE);
 754:	c8 ed       	ldi	r28, 0xD8	; 216
 756:	d0 e0       	ldi	r29, 0x00	; 0
 758:	88 81       	ld	r24, Y
 75a:	8f 77       	andi	r24, 0x7F	; 127
 75c:	88 83       	st	Y, r24
				USBCON |=  (1 << USBE);
 75e:	88 81       	ld	r24, Y
 760:	80 68       	ori	r24, 0x80	; 128
 762:	88 83       	st	Y, r24
			}

			static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE;
			static inline void USB_CLK_Unfreeze(void)
			{
				USBCON &= ~(1 << FRZCLK);
 764:	88 81       	ld	r24, Y
 766:	8f 7d       	andi	r24, 0xDF	; 223
 768:	88 83       	st	Y, r24
			}

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

#if defined(USB_CAN_BE_DEVICE)
static void USB_Init_Device(void)
{
	USB_DeviceState                 = DEVICE_STATE_Unattached;
 76c:	10 92 13 01 	sts	0x0113, r1
	USB_Device_ConfigurationNumber  = 0;
 770:	10 92 0f 01 	sts	0x010F, r1

	#if !defined(NO_DEVICE_REMOTE_WAKEUP)
	USB_Device_RemoteWakeupEnabled  = false;
 774:	10 92 11 01 	sts	0x0111, r1
	#endif

	#if !defined(NO_DEVICE_SELF_POWER)
	USB_Device_CurrentlySelfPowered = false;
 778:	10 92 10 01 	sts	0x0110, r1
			}

			static inline void USB_Device_SetFullSpeed(void) ATTR_ALWAYS_INLINE;
			static inline void USB_Device_SetFullSpeed(void)
			{
				UDCON &= ~(1 << LSM);
 77c:	00 ee       	ldi	r16, 0xE0	; 224
 77e:	10 e0       	ldi	r17, 0x00	; 0
 780:	f8 01       	movw	r30, r16
 782:	80 81       	ld	r24, Z
 784:	8b 7f       	andi	r24, 0xFB	; 251
 786:	80 83       	st	Z, r24
			{
				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);
 788:	88 81       	ld	r24, Y
 78a:	81 60       	ori	r24, 0x01	; 1
 78c:	88 83       	st	Y, r24
				uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);

				if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
				  return false;

				return Endpoint_ConfigureEndpoint_Prv(Number,
 78e:	42 e0       	ldi	r20, 0x02	; 2
 790:	60 e0       	ldi	r22, 0x00	; 0
 792:	80 e0       	ldi	r24, 0x00	; 0
 794:	0f df       	rcall	.-482    	; 0x5b4 <Endpoint_ConfigureEndpoint_Prv>
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDINT  &= ~(1 << WAKEUPI);
						break;
					case USB_INT_SUSPI:
						UDINT  &= ~(1 << SUSPI);
 796:	e1 ee       	ldi	r30, 0xE1	; 225
 798:	f0 e0       	ldi	r31, 0x00	; 0
 79a:	80 81       	ld	r24, Z
 79c:	8e 7f       	andi	r24, 0xFE	; 254
 79e:	80 83       	st	Z, r24
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  |= (1 << WAKEUPE);
						break;
					case USB_INT_SUSPI:
						UDIEN  |= (1 << SUSPE);
 7a0:	e2 ee       	ldi	r30, 0xE2	; 226
 7a2:	f0 e0       	ldi	r31, 0x00	; 0
 7a4:	80 81       	ld	r24, Z
 7a6:	81 60       	ori	r24, 0x01	; 1
 7a8:	80 83       	st	Z, r24
						break;
					case USB_INT_EORSTI:
						UDIEN  |= (1 << EORSTE);
 7aa:	80 81       	ld	r24, Z
 7ac:	88 60       	ori	r24, 0x08	; 8
 7ae:	80 83       	st	Z, r24
			 *  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);
 7b0:	f8 01       	movw	r30, r16
 7b2:	80 81       	ld	r24, Z
 7b4:	8e 7f       	andi	r24, 0xFE	; 254
 7b6:	80 83       	st	Z, r24

			#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);
 7b8:	88 81       	ld	r24, Y
 7ba:	80 61       	ori	r24, 0x10	; 16
 7bc:	88 83       	st	Y, r24
	}

	#if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
	USB_OTGPAD_On();
	#endif
}
 7be:	df 91       	pop	r29
 7c0:	cf 91       	pop	r28
 7c2:	1f 91       	pop	r17
 7c4:	0f 91       	pop	r16
 7c6:	08 95       	ret

000007c8 <USB_Init>:
			}

			static inline void USB_OTGPAD_Off(void) ATTR_ALWAYS_INLINE;
			static inline void USB_OTGPAD_Off(void)
			{
				USBCON &= ~(1 << OTGPADE);
 7c8:	e8 ed       	ldi	r30, 0xD8	; 216
 7ca:	f0 e0       	ldi	r31, 0x00	; 0
 7cc:	80 81       	ld	r24, Z
 7ce:	8f 7e       	andi	r24, 0xEF	; 239
 7d0:	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);
 7d2:	e7 ed       	ldi	r30, 0xD7	; 215
 7d4:	f0 e0       	ldi	r31, 0x00	; 0
 7d6:	80 81       	ld	r24, Z
 7d8:	81 60       	ori	r24, 0x01	; 1
 7da:	80 83       	st	Z, r24
	  USB_REG_Off();

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

	USB_IsInitialized = true;
 7e0:	81 e0       	ldi	r24, 0x01	; 1
 7e2:	80 93 12 01 	sts	0x0112, r24

	USB_ResetInterface();
 7e6:	b0 cf       	rjmp	.-160    	; 0x748 <USB_ResetInterface>
 7e8:	08 95       	ret

000007ea <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);
 7ea:	e8 ed       	ldi	r30, 0xD8	; 216
 7ec:	f0 e0       	ldi	r31, 0x00	; 0
 7ee:	80 81       	ld	r24, Z
 7f0:	8e 7f       	andi	r24, 0xFE	; 254
 7f2:	80 83       	st	Z, r24
	#if defined(USB_CAN_BE_HOST)
	UHIEN   = 0;
	#endif

	#if defined(USB_CAN_BE_DEVICE)
	UDIEN   = 0;
 7f4:	10 92 e2 00 	sts	0x00E2, r1
 7f8:	08 95       	ret

000007fa <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;
 7fa:	10 92 da 00 	sts	0x00DA, r1
	#if defined(USB_CAN_BE_HOST)
	UHINT  = 0;
	#endif

	#if defined(USB_CAN_BE_DEVICE)
	UDINT  = 0;
 7fe:	10 92 e1 00 	sts	0x00E1, r1
 802:	08 95       	ret

00000804 <__vector_10>:
	#endif
}

ISR(USB_GEN_vect, ISR_BLOCK)
{
 804:	1f 92       	push	r1
 806:	0f 92       	push	r0
 808:	0f b6       	in	r0, 0x3f	; 63
 80a:	0f 92       	push	r0
 80c:	11 24       	eor	r1, r1
 80e:	2f 93       	push	r18
 810:	3f 93       	push	r19
 812:	4f 93       	push	r20
 814:	5f 93       	push	r21
 816:	6f 93       	push	r22
 818:	7f 93       	push	r23
 81a:	8f 93       	push	r24
 81c:	9f 93       	push	r25
 81e:	af 93       	push	r26
 820:	bf 93       	push	r27
 822:	ef 93       	push	r30
 824:	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));
 826:	80 91 e1 00 	lds	r24, 0x00E1
	#if defined(USB_CAN_BE_DEVICE)
	#if !defined(NO_SOF_EVENTS)
	if (USB_INT_HasOccurred(USB_INT_SOFI) && USB_INT_IsEnabled(USB_INT_SOFI))
 82a:	82 ff       	sbrs	r24, 2
 82c:	0a c0       	rjmp	.+20     	; 0x842 <__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));
 82e:	80 91 e2 00 	lds	r24, 0x00E2
 832:	82 ff       	sbrs	r24, 2
 834:	06 c0       	rjmp	.+12     	; 0x842 <__vector_10+0x3e>
						break;
					case USB_INT_EORSTI:
						UDINT  &= ~(1 << EORSTI);
						break;
					case USB_INT_SOFI:
						UDINT  &= ~(1 << SOFI);
 836:	e1 ee       	ldi	r30, 0xE1	; 225
 838:	f0 e0       	ldi	r31, 0x00	; 0
 83a:	80 81       	ld	r24, Z
 83c:	8b 7f       	andi	r24, 0xFB	; 251
 83e:	80 83       	st	Z, r24
	{
		USB_INT_Clear(USB_INT_SOFI);

		EVENT_USB_Device_StartOfFrame();
 840:	03 d2       	rcall	.+1030   	; 0xc48 <USB_Event_Stub>
			{
				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));
 842:	80 91 da 00 	lds	r24, 0x00DA
	}
	#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))
 846:	80 ff       	sbrs	r24, 0
 848:	1d c0       	rjmp	.+58     	; 0x884 <__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));
 84a:	80 91 d8 00 	lds	r24, 0x00D8
 84e:	80 ff       	sbrs	r24, 0
 850:	19 c0       	rjmp	.+50     	; 0x884 <__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);
 852:	ea ed       	ldi	r30, 0xDA	; 218
 854:	f0 e0       	ldi	r31, 0x00	; 0
 856:	80 81       	ld	r24, Z
 858:	8e 7f       	andi	r24, 0xFE	; 254
 85a:	80 83       	st	Z, r24
				 *  \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);
 85c:	80 91 d9 00 	lds	r24, 0x00D9
	{
		USB_INT_Clear(USB_INT_VBUSTI);

		if (USB_VBUS_GetStatus())
 860:	80 ff       	sbrs	r24, 0
 862:	0c c0       	rjmp	.+24     	; 0x87c <__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;
 864:	80 e1       	ldi	r24, 0x10	; 16
 866:	89 bd       	out	0x29, r24	; 41
				PLLCSR = (USB_PLL_PSC | (1 << PLLE));
 868:	82 e1       	ldi	r24, 0x12	; 18
 86a:	89 bd       	out	0x29, r24	; 41
		{
			if (!(USB_Options & USB_OPT_MANUAL_PLL))
			{
				USB_PLL_On();
				while (!(USB_PLL_IsReady()));
 86c:	09 b4       	in	r0, 0x29	; 41
 86e:	00 fe       	sbrs	r0, 0
 870:	fd cf       	rjmp	.-6      	; 0x86c <__vector_10+0x68>
			}

			USB_DeviceState = DEVICE_STATE_Powered;
 872:	81 e0       	ldi	r24, 0x01	; 1
 874:	80 93 13 01 	sts	0x0113, r24
			EVENT_USB_Device_Connect();
 878:	19 d2       	rcall	.+1074   	; 0xcac <EVENT_USB_Device_Connect>
 87a:	04 c0       	rjmp	.+8      	; 0x884 <__vector_10+0x80>
			}

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

			USB_DeviceState = DEVICE_STATE_Unattached;
 87e:	10 92 13 01 	sts	0x0113, r1
			EVENT_USB_Device_Disconnect();
 882:	15 d2       	rcall	.+1066   	; 0xcae <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));
 884:	80 91 e1 00 	lds	r24, 0x00E1
		}
	}
	#endif

	if (USB_INT_HasOccurred(USB_INT_SUSPI) && USB_INT_IsEnabled(USB_INT_SUSPI))
 888:	80 ff       	sbrs	r24, 0
 88a:	16 c0       	rjmp	.+44     	; 0x8b8 <__vector_10+0xb4>
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						return (UDIEN  & (1 << WAKEUPE));
					case USB_INT_SUSPI:
						return (UDIEN  & (1 << SUSPE));
 88c:	80 91 e2 00 	lds	r24, 0x00E2
 890:	80 ff       	sbrs	r24, 0
 892:	12 c0       	rjmp	.+36     	; 0x8b8 <__vector_10+0xb4>
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  &= ~(1 << WAKEUPE);
						break;
					case USB_INT_SUSPI:
						UDIEN  &= ~(1 << SUSPE);
 894:	e2 ee       	ldi	r30, 0xE2	; 226
 896:	f0 e0       	ldi	r31, 0x00	; 0
 898:	80 81       	ld	r24, Z
 89a:	8e 7f       	andi	r24, 0xFE	; 254
 89c:	80 83       	st	Z, r24
						USBCON |= (1 << IDTE);
						break;
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  |= (1 << WAKEUPE);
 89e:	80 81       	ld	r24, Z
 8a0:	80 61       	ori	r24, 0x10	; 16
 8a2:	80 83       	st	Z, r24
			#endif

			static inline void USB_CLK_Freeze(void) ATTR_ALWAYS_INLINE;
			static inline void USB_CLK_Freeze(void)
			{
				USBCON |=  (1 << FRZCLK);
 8a4:	e8 ed       	ldi	r30, 0xD8	; 216
 8a6:	f0 e0       	ldi	r31, 0x00	; 0
 8a8:	80 81       	ld	r24, Z
 8aa:	80 62       	ori	r24, 0x20	; 32
 8ac:	80 83       	st	Z, r24
			}

			static inline void USB_PLL_Off(void) ATTR_ALWAYS_INLINE;
			static inline void USB_PLL_Off(void)
			{
				PLLCSR = 0;
 8ae:	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;
 8b0:	85 e0       	ldi	r24, 0x05	; 5
 8b2:	80 93 13 01 	sts	0x0113, r24
		EVENT_USB_Device_Suspend();
 8b6:	c8 d1       	rcall	.+912    	; 0xc48 <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));
 8b8:	80 91 e1 00 	lds	r24, 0x00E1
		#endif
	}

	if (USB_INT_HasOccurred(USB_INT_WAKEUPI) && USB_INT_IsEnabled(USB_INT_WAKEUPI))
 8bc:	84 ff       	sbrs	r24, 4
 8be:	2f c0       	rjmp	.+94     	; 0x91e <__vector_10+0x11a>
					case USB_INT_IDTI:
						return (USBCON & (1 << IDTE));
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						return (UDIEN  & (1 << WAKEUPE));
 8c0:	80 91 e2 00 	lds	r24, 0x00E2
 8c4:	84 ff       	sbrs	r24, 4
 8c6:	2b c0       	rjmp	.+86     	; 0x91e <__vector_10+0x11a>

		/* Inline Functions: */
			static inline void USB_PLL_On(void) ATTR_ALWAYS_INLINE;
			static inline void USB_PLL_On(void)
			{
				PLLCSR = USB_PLL_PSC;
 8c8:	80 e1       	ldi	r24, 0x10	; 16
 8ca:	89 bd       	out	0x29, r24	; 41
				PLLCSR = (USB_PLL_PSC | (1 << PLLE));
 8cc:	82 e1       	ldi	r24, 0x12	; 18
 8ce:	89 bd       	out	0x29, r24	; 41
	{
		if (!(USB_Options & USB_OPT_MANUAL_PLL))
		{
			USB_PLL_On();
			while (!(USB_PLL_IsReady()));
 8d0:	09 b4       	in	r0, 0x29	; 41
 8d2:	00 fe       	sbrs	r0, 0
 8d4:	fd cf       	rjmp	.-6      	; 0x8d0 <__vector_10+0xcc>
			}

			static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE;
			static inline void USB_CLK_Unfreeze(void)
			{
				USBCON &= ~(1 << FRZCLK);
 8d6:	e8 ed       	ldi	r30, 0xD8	; 216
 8d8:	f0 e0       	ldi	r31, 0x00	; 0
 8da:	80 81       	ld	r24, Z
 8dc:	8f 7d       	andi	r24, 0xDF	; 223
 8de:	80 83       	st	Z, r24
						USBINT &= ~(1 << IDTI);
						break;
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDINT  &= ~(1 << WAKEUPI);
 8e0:	e1 ee       	ldi	r30, 0xE1	; 225
 8e2:	f0 e0       	ldi	r31, 0x00	; 0
 8e4:	80 81       	ld	r24, Z
 8e6:	8f 7e       	andi	r24, 0xEF	; 239
 8e8:	80 83       	st	Z, r24
						USBCON &= ~(1 << IDTE);
						break;
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  &= ~(1 << WAKEUPE);
 8ea:	e2 ee       	ldi	r30, 0xE2	; 226
 8ec:	f0 e0       	ldi	r31, 0x00	; 0
 8ee:	80 81       	ld	r24, Z
 8f0:	8f 7e       	andi	r24, 0xEF	; 239
 8f2:	80 83       	st	Z, r24
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  |= (1 << WAKEUPE);
						break;
					case USB_INT_SUSPI:
						UDIEN  |= (1 << SUSPE);
 8f4:	80 81       	ld	r24, Z
 8f6:	81 60       	ori	r24, 0x01	; 1
 8f8:	80 83       	st	Z, r24
		USB_INT_Clear(USB_INT_WAKEUPI);

		USB_INT_Disable(USB_INT_WAKEUPI);
		USB_INT_Enable(USB_INT_SUSPI);

		if (USB_Device_ConfigurationNumber)
 8fa:	80 91 0f 01 	lds	r24, 0x010F
 8fe:	88 23       	and	r24, r24
 900:	21 f0       	breq	.+8      	; 0x90a <__vector_10+0x106>
		  USB_DeviceState = DEVICE_STATE_Configured;
 902:	84 e0       	ldi	r24, 0x04	; 4
 904:	80 93 13 01 	sts	0x0113, r24
 908:	09 c0       	rjmp	.+18     	; 0x91c <__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));
 90a:	80 91 e3 00 	lds	r24, 0x00E3
		else
		  USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Addressed : DEVICE_STATE_Powered;
 90e:	88 23       	and	r24, r24
 910:	14 f4       	brge	.+4      	; 0x916 <__vector_10+0x112>
 912:	83 e0       	ldi	r24, 0x03	; 3
 914:	01 c0       	rjmp	.+2      	; 0x918 <__vector_10+0x114>
 916:	81 e0       	ldi	r24, 0x01	; 1
 918:	80 93 13 01 	sts	0x0113, r24

		#if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
		EVENT_USB_Device_Connect();
		#else
		EVENT_USB_Device_WakeUp();
 91c:	95 d1       	rcall	.+810    	; 0xc48 <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));
 91e:	80 91 e1 00 	lds	r24, 0x00E1
		#endif
	}

	if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI))
 922:	83 ff       	sbrs	r24, 3
 924:	1e c0       	rjmp	.+60     	; 0x962 <__vector_10+0x15e>
					case USB_INT_WAKEUPI:
						return (UDIEN  & (1 << WAKEUPE));
					case USB_INT_SUSPI:
						return (UDIEN  & (1 << SUSPE));
					case USB_INT_EORSTI:
						return (UDIEN  & (1 << EORSTE));
 926:	80 91 e2 00 	lds	r24, 0x00E2
 92a:	83 ff       	sbrs	r24, 3
 92c:	1a c0       	rjmp	.+52     	; 0x962 <__vector_10+0x15e>
						break;
					case USB_INT_SUSPI:
						UDINT  &= ~(1 << SUSPI);
						break;
					case USB_INT_EORSTI:
						UDINT  &= ~(1 << EORSTI);
 92e:	e1 ee       	ldi	r30, 0xE1	; 225
 930:	f0 e0       	ldi	r31, 0x00	; 0
 932:	80 81       	ld	r24, Z
 934:	87 7f       	andi	r24, 0xF7	; 247
 936:	80 83       	st	Z, r24
	{
		USB_INT_Clear(USB_INT_EORSTI);

		USB_DeviceState                = DEVICE_STATE_Default;
 938:	82 e0       	ldi	r24, 0x02	; 2
 93a:	80 93 13 01 	sts	0x0113, r24
		USB_Device_ConfigurationNumber = 0;
 93e:	10 92 0f 01 	sts	0x010F, r1
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDINT  &= ~(1 << WAKEUPI);
						break;
					case USB_INT_SUSPI:
						UDINT  &= ~(1 << SUSPI);
 942:	80 81       	ld	r24, Z
 944:	8e 7f       	andi	r24, 0xFE	; 254
 946:	80 83       	st	Z, r24
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  &= ~(1 << WAKEUPE);
						break;
					case USB_INT_SUSPI:
						UDIEN  &= ~(1 << SUSPE);
 948:	e2 ee       	ldi	r30, 0xE2	; 226
 94a:	f0 e0       	ldi	r31, 0x00	; 0
 94c:	80 81       	ld	r24, Z
 94e:	8e 7f       	andi	r24, 0xFE	; 254
 950:	80 83       	st	Z, r24
						USBCON |= (1 << IDTE);
						break;
					#endif
					#if defined(USB_CAN_BE_DEVICE)
					case USB_INT_WAKEUPI:
						UDIEN  |= (1 << WAKEUPE);
 952:	80 81       	ld	r24, Z
 954:	80 61       	ori	r24, 0x10	; 16
 956:	80 83       	st	Z, r24
				uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);

				if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
				  return false;

				return Endpoint_ConfigureEndpoint_Prv(Number,
 958:	42 e0       	ldi	r20, 0x02	; 2
 95a:	60 e0       	ldi	r22, 0x00	; 0
 95c:	80 e0       	ldi	r24, 0x00	; 0
 95e:	2a de       	rcall	.-940    	; 0x5b4 <Endpoint_ConfigureEndpoint_Prv>

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

		EVENT_USB_Device_Reset();
 960:	73 d1       	rcall	.+742    	; 0xc48 <USB_Event_Stub>
		USB_ResetInterface();

		EVENT_USB_UIDChange();
	}
	#endif
}
 962:	ff 91       	pop	r31
 964:	ef 91       	pop	r30
 966:	bf 91       	pop	r27
 968:	af 91       	pop	r26
 96a:	9f 91       	pop	r25
 96c:	8f 91       	pop	r24
 96e:	7f 91       	pop	r23
 970:	6f 91       	pop	r22
 972:	5f 91       	pop	r21
 974:	4f 91       	pop	r20
 976:	3f 91       	pop	r19
 978:	2f 91       	pop	r18
 97a:	0f 90       	pop	r0
 97c:	0f be       	out	0x3f, r0	; 63
 97e:	0f 90       	pop	r0
 980:	1f 90       	pop	r1
 982:	18 95       	reti

00000984 <USB_Device_ProcessControlRequest>:
#if !defined(NO_DEVICE_REMOTE_WAKEUP)
bool    USB_Device_RemoteWakeupEnabled;
#endif

void USB_Device_ProcessControlRequest(void)
{
 984:	0f 93       	push	r16
 986:	1f 93       	push	r17
 988:	cf 93       	push	r28
 98a:	df 93       	push	r29
 98c:	cd b7       	in	r28, 0x3d	; 61
 98e:	de b7       	in	r29, 0x3e	; 62
 990:	aa 97       	sbiw	r28, 0x2a	; 42
 992:	0f b6       	in	r0, 0x3f	; 63
 994:	f8 94       	cli
 996:	de bf       	out	0x3e, r29	; 62
 998:	0f be       	out	0x3f, r0	; 63
 99a:	cd bf       	out	0x3d, r28	; 61
 99c:	e4 e1       	ldi	r30, 0x14	; 20
 99e:	f1 e0       	ldi	r31, 0x01	; 1
 9a0:	8c e1       	ldi	r24, 0x1C	; 28
 9a2:	91 e0       	ldi	r25, 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;
 9a4:	a1 ef       	ldi	r26, 0xF1	; 241
 9a6:	b0 e0       	ldi	r27, 0x00	; 0
 9a8:	2c 91       	ld	r18, X
	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();
 9aa:	21 93       	st	Z+, r18
	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++)
 9ac:	e8 17       	cp	r30, r24
 9ae:	f9 07       	cpc	r31, r25
 9b0:	d9 f7       	brne	.-10     	; 0x9a8 <USB_Device_ProcessControlRequest+0x24>
	  *(RequestHeader++) = Endpoint_Read_8();
	#endif

	EVENT_USB_Device_ControlRequest();
 9b2:	93 d1       	rcall	.+806    	; 0xcda <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);
 9b4:	80 91 e8 00 	lds	r24, 0x00E8

	if (Endpoint_IsSETUPReceived())
 9b8:	83 ff       	sbrs	r24, 3
 9ba:	21 c1       	rjmp	.+578    	; 0xbfe <__stack+0xff>
	{
		uint8_t bmRequestType = USB_ControlRequest.bmRequestType;
 9bc:	30 91 14 01 	lds	r19, 0x0114

		switch (USB_ControlRequest.bRequest)
 9c0:	20 91 15 01 	lds	r18, 0x0115
 9c4:	82 2f       	mov	r24, r18
 9c6:	90 e0       	ldi	r25, 0x00	; 0
 9c8:	8a 30       	cpi	r24, 0x0A	; 10
 9ca:	91 05       	cpc	r25, r1
 9cc:	08 f0       	brcs	.+2      	; 0x9d0 <USB_Device_ProcessControlRequest+0x4c>
 9ce:	17 c1       	rjmp	.+558    	; 0xbfe <__stack+0xff>
 9d0:	fc 01       	movw	r30, r24
 9d2:	ea 5a       	subi	r30, 0xAA	; 170
 9d4:	ff 4f       	sbci	r31, 0xFF	; 255
 9d6:	01 c2       	rjmp	.+1026   	; 0xdda <__tablejump2__>
		{
			case REQ_GetStatus:
				if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
 9d8:	30 38       	cpi	r19, 0x80	; 128
 9da:	21 f0       	breq	.+8      	; 0x9e4 <USB_Device_ProcessControlRequest+0x60>
 9dc:	32 38       	cpi	r19, 0x82	; 130
 9de:	09 f0       	breq	.+2      	; 0x9e2 <USB_Device_ProcessControlRequest+0x5e>
 9e0:	0e c1       	rjmp	.+540    	; 0xbfe <__stack+0xff>
 9e2:	08 c0       	rjmp	.+16     	; 0x9f4 <USB_Device_ProcessControlRequest+0x70>
	Endpoint_ClearOUT();
}

static void USB_Device_GetStatus(void)
{
	uint8_t CurrentStatus = 0;
 9e4:	80 91 10 01 	lds	r24, 0x0110
			if (USB_Device_CurrentlySelfPowered)
			  CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
			#endif

			#if !defined(NO_DEVICE_REMOTE_WAKEUP)
			if (USB_Device_RemoteWakeupEnabled)
 9e8:	90 91 11 01 	lds	r25, 0x0111
 9ec:	99 23       	and	r25, r25
 9ee:	71 f0       	breq	.+28     	; 0xa0c <USB_Device_ProcessControlRequest+0x88>
			  CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
 9f0:	82 60       	ori	r24, 0x02	; 2
 9f2:	0c c0       	rjmp	.+24     	; 0xa0c <USB_Device_ProcessControlRequest+0x88>
			 */
			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);
 9f4:	80 91 18 01 	lds	r24, 0x0118
 9f8:	8f 70       	andi	r24, 0x0F	; 15
 9fa:	e9 ee       	ldi	r30, 0xE9	; 233
 9fc:	f0 e0       	ldi	r31, 0x00	; 0
 9fe:	80 83       	st	Z, r24
			 *  \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);
 a00:	80 91 eb 00 	lds	r24, 0x00EB
 a04:	85 fb       	bst	r24, 5
 a06:	88 27       	eor	r24, r24
 a08:	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);
 a0a:	10 82       	st	Z, r1
			 *  \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);
 a0c:	e8 ee       	ldi	r30, 0xE8	; 232
 a0e:	f0 e0       	ldi	r31, 0x00	; 0
 a10:	90 81       	ld	r25, Z
 a12:	97 7f       	andi	r25, 0xF7	; 247
 a14:	90 83       	st	Z, r25
			 *  \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);
 a16:	a1 ef       	ldi	r26, 0xF1	; 241
 a18:	b0 e0       	ldi	r27, 0x00	; 0
 a1a:	8c 93       	st	X, r24
				UEDATX = (Data >> 8);
 a1c:	1c 92       	st	X, r1
			 */
			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));
 a1e:	80 81       	ld	r24, Z
 a20:	8e 77       	andi	r24, 0x7E	; 126
 a22:	80 83       	st	Z, r24
	Endpoint_ClearSETUP();

	Endpoint_Write_16_LE(CurrentStatus);
	Endpoint_ClearIN();

	Endpoint_ClearStatusStage();
 a24:	2b de       	rcall	.-938    	; 0x67c <Endpoint_ClearStatusStage>
 a26:	eb c0       	rjmp	.+470    	; 0xbfe <__stack+0xff>
				}

				break;
			case REQ_ClearFeature:
			case REQ_SetFeature:
				if ((bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE)) ||
 a28:	33 23       	and	r19, r19
 a2a:	09 f4       	brne	.+2      	; 0xa2e <USB_Device_ProcessControlRequest+0xaa>
 a2c:	f7 c0       	rjmp	.+494    	; 0xc1c <__stack+0x11d>
 a2e:	32 30       	cpi	r19, 0x02	; 2
 a30:	09 f0       	breq	.+2      	; 0xa34 <USB_Device_ProcessControlRequest+0xb0>
 a32:	e5 c0       	rjmp	.+458    	; 0xbfe <__stack+0xff>
 a34:	f8 c0       	rjmp	.+496    	; 0xc26 <__stack+0x127>
	switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
	{
		#if !defined(NO_DEVICE_REMOTE_WAKEUP)
		case REQREC_DEVICE:
			if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_DeviceRemoteWakeup)
			  USB_Device_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
 a36:	81 e0       	ldi	r24, 0x01	; 1
 a38:	23 30       	cpi	r18, 0x03	; 3
 a3a:	09 f0       	breq	.+2      	; 0xa3e <USB_Device_ProcessControlRequest+0xba>
 a3c:	80 e0       	ldi	r24, 0x00	; 0
 a3e:	80 93 11 01 	sts	0x0111, r24
 a42:	28 c0       	rjmp	.+80     	; 0xa94 <USB_Device_ProcessControlRequest+0x110>
		#endif
		#if !defined(CONTROL_ONLY_DEVICE)
		case REQREC_ENDPOINT:
			if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_EndpointHalt)
			{
				uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 a44:	20 91 18 01 	lds	r18, 0x0118
 a48:	2f 70       	andi	r18, 0x0F	; 15

				if (EndpointIndex == ENDPOINT_CONTROLEP)
 a4a:	09 f4       	brne	.+2      	; 0xa4e <USB_Device_ProcessControlRequest+0xca>
 a4c:	d8 c0       	rjmp	.+432    	; 0xbfe <__stack+0xff>
			 */
			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);
 a4e:	20 93 e9 00 	sts	0x00E9, r18
			 * \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);
 a52:	80 91 eb 00 	lds	r24, 0x00EB
				  return;

				Endpoint_SelectEndpoint(EndpointIndex);

				if (Endpoint_IsEnabled())
 a56:	80 ff       	sbrs	r24, 0
 a58:	1d c0       	rjmp	.+58     	; 0xa94 <USB_Device_ProcessControlRequest+0x110>
				{
					if (USB_ControlRequest.bRequest == REQ_SetFeature)
 a5a:	80 91 15 01 	lds	r24, 0x0115
 a5e:	83 30       	cpi	r24, 0x03	; 3
 a60:	31 f4       	brne	.+12     	; 0xa6e <USB_Device_ProcessControlRequest+0xea>
			 *  \ingroup Group_EndpointPacketManagement_AVR8
			 */
			static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_StallTransaction(void)
			{
				UECONX |= (1 << STALLRQ);
 a62:	eb ee       	ldi	r30, 0xEB	; 235
 a64:	f0 e0       	ldi	r31, 0x00	; 0
 a66:	80 81       	ld	r24, Z
 a68:	80 62       	ori	r24, 0x20	; 32
 a6a:	80 83       	st	Z, r24
 a6c:	13 c0       	rjmp	.+38     	; 0xa94 <USB_Device_ProcessControlRequest+0x110>
			 *  \ingroup Group_EndpointPacketManagement_AVR8
			 */
			static inline void Endpoint_ClearStall(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_ClearStall(void)
			{
				UECONX |= (1 << STALLRQC);
 a6e:	eb ee       	ldi	r30, 0xEB	; 235
 a70:	f0 e0       	ldi	r31, 0x00	; 0
 a72:	80 81       	ld	r24, Z
 a74:	80 61       	ori	r24, 0x10	; 16
 a76:	80 83       	st	Z, r24
			 *  \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));
 a78:	81 e0       	ldi	r24, 0x01	; 1
 a7a:	90 e0       	ldi	r25, 0x00	; 0
 a7c:	02 c0       	rjmp	.+4      	; 0xa82 <USB_Device_ProcessControlRequest+0xfe>
 a7e:	88 0f       	add	r24, r24
 a80:	99 1f       	adc	r25, r25
 a82:	2a 95       	dec	r18
 a84:	e2 f7       	brpl	.-8      	; 0xa7e <USB_Device_ProcessControlRequest+0xfa>
 a86:	aa ee       	ldi	r26, 0xEA	; 234
 a88:	b0 e0       	ldi	r27, 0x00	; 0
 a8a:	8c 93       	st	X, r24
				UERST = 0;
 a8c:	1c 92       	st	X, r1

			/** 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);
 a8e:	80 81       	ld	r24, Z
 a90:	88 60       	ori	r24, 0x08	; 8
 a92:	80 83       	st	Z, 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);
 a94:	10 92 e9 00 	sts	0x00E9, r1
			 *  \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);
 a98:	e8 ee       	ldi	r30, 0xE8	; 232
 a9a:	f0 e0       	ldi	r31, 0x00	; 0
 a9c:	80 81       	ld	r24, Z
 a9e:	87 7f       	andi	r24, 0xF7	; 247
 aa0:	80 83       	st	Z, r24

	Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);

	Endpoint_ClearSETUP();

	Endpoint_ClearStatusStage();
 aa2:	ec dd       	rcall	.-1064   	; 0x67c <Endpoint_ClearStatusStage>
 aa4:	ac c0       	rjmp	.+344    	; 0xbfe <__stack+0xff>
					USB_Device_ClearSetFeature();
				}

				break;
			case REQ_SetAddress:
				if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
 aa6:	31 11       	cpse	r19, r1
 aa8:	aa c0       	rjmp	.+340    	; 0xbfe <__stack+0xff>
	}
}

static void USB_Device_SetAddress(void)
{
	uint8_t DeviceAddress = (USB_ControlRequest.wValue & 0x7F);
 aaa:	10 91 16 01 	lds	r17, 0x0116
 aae:	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);
 ab0:	e3 ee       	ldi	r30, 0xE3	; 227
 ab2:	f0 e0       	ldi	r31, 0x00	; 0
 ab4:	80 81       	ld	r24, Z
 ab6:	80 78       	andi	r24, 0x80	; 128
 ab8:	81 2b       	or	r24, r17
 aba:	80 83       	st	Z, r24
 abc:	e8 ee       	ldi	r30, 0xE8	; 232
 abe:	f0 e0       	ldi	r31, 0x00	; 0
 ac0:	80 81       	ld	r24, Z
 ac2:	87 7f       	andi	r24, 0xF7	; 247
 ac4:	80 83       	st	Z, r24

	USB_Device_SetDeviceAddress(DeviceAddress);

	Endpoint_ClearSETUP();

	Endpoint_ClearStatusStage();
 ac6:	da dd       	rcall	.-1100   	; 0x67c <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);
 ac8:	e8 ee       	ldi	r30, 0xE8	; 232
 aca:	f0 e0       	ldi	r31, 0x00	; 0
 acc:	80 81       	ld	r24, Z

	while (!(Endpoint_IsINReady()));
 ace:	80 ff       	sbrs	r24, 0
 ad0:	fd cf       	rjmp	.-6      	; 0xacc <USB_Device_ProcessControlRequest+0x148>
			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);
 ad2:	e3 ee       	ldi	r30, 0xE3	; 227
 ad4:	f0 e0       	ldi	r31, 0x00	; 0
 ad6:	80 81       	ld	r24, Z
 ad8:	80 68       	ori	r24, 0x80	; 128
 ada:	80 83       	st	Z, r24

	USB_Device_EnableDeviceAddress(DeviceAddress);

	USB_DeviceState = (DeviceAddress) ? DEVICE_STATE_Addressed : DEVICE_STATE_Default;
 adc:	11 23       	and	r17, r17
 ade:	11 f0       	breq	.+4      	; 0xae4 <USB_Device_ProcessControlRequest+0x160>
 ae0:	83 e0       	ldi	r24, 0x03	; 3
 ae2:	01 c0       	rjmp	.+2      	; 0xae6 <USB_Device_ProcessControlRequest+0x162>
 ae4:	82 e0       	ldi	r24, 0x02	; 2
 ae6:	80 93 13 01 	sts	0x0113, r24
 aea:	89 c0       	rjmp	.+274    	; 0xbfe <__stack+0xff>
				if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
				  USB_Device_SetAddress();

				break;
			case REQ_GetDescriptor:
				if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
 aec:	30 58       	subi	r19, 0x80	; 128
 aee:	32 30       	cpi	r19, 0x02	; 2
 af0:	08 f0       	brcs	.+2      	; 0xaf4 <USB_Device_ProcessControlRequest+0x170>
 af2:	85 c0       	rjmp	.+266    	; 0xbfe <__stack+0xff>
	    !(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))
 af4:	80 91 16 01 	lds	r24, 0x0116
 af8:	90 91 17 01 	lds	r25, 0x0117
 afc:	8c 3d       	cpi	r24, 0xDC	; 220
 afe:	23 e0       	ldi	r18, 0x03	; 3
 b00:	92 07       	cpc	r25, r18
 b02:	99 f5       	brne	.+102    	; 0xb6a <__stack+0x6b>
	{
		USB_Descriptor_Header_t Header;
		uint16_t                UnicodeString[INTERNAL_SERIAL_LENGTH_BITS / 4];
	} SignatureDescriptor;

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

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

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

				GCC_MEMORY_BARRIER();
 b10:	de 01       	movw	r26, r28
 b12:	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++)
 b14:	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;
 b16:	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);
 b18:	41 e2       	ldi	r20, 0x21	; 33
 b1a:	e3 2f       	mov	r30, r19
 b1c:	f0 e0       	ldi	r31, 0x00	; 0
 b1e:	40 93 57 00 	sts	0x0057, r20
 b22:	84 91       	lpm	r24, Z

					if (SerialCharNum & 0x01)
 b24:	20 ff       	sbrs	r18, 0
 b26:	03 c0       	rjmp	.+6      	; 0xb2e <__stack+0x2f>
					{
						SerialByte >>= 4;
 b28:	82 95       	swap	r24
 b2a:	8f 70       	andi	r24, 0x0F	; 15
						SigReadAddress++;
 b2c:	3f 5f       	subi	r19, 0xFF	; 255
					}

					SerialByte &= 0x0F;
 b2e:	8f 70       	andi	r24, 0x0F	; 15

					UnicodeString[SerialCharNum] = cpu_to_le16((SerialByte >= 10) ?
 b30:	8a 30       	cpi	r24, 0x0A	; 10
 b32:	18 f0       	brcs	.+6      	; 0xb3a <__stack+0x3b>
 b34:	90 e0       	ldi	r25, 0x00	; 0
 b36:	c7 96       	adiw	r24, 0x37	; 55
 b38:	02 c0       	rjmp	.+4      	; 0xb3e <__stack+0x3f>
 b3a:	90 e0       	ldi	r25, 0x00	; 0
 b3c:	c0 96       	adiw	r24, 0x30	; 48
 b3e:	8d 93       	st	X+, r24
 b40:	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++)
 b42:	2f 5f       	subi	r18, 0xFF	; 255
 b44:	24 31       	cpi	r18, 0x14	; 20
 b46:	49 f7       	brne	.-46     	; 0xb1a <__stack+0x1b>
			static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
			{
				GCC_MEMORY_BARRIER();

				#if (ARCH == ARCH_AVR8)
				SREG = GlobalIntState;
 b48:	5f bf       	out	0x3f, r21	; 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);
 b4a:	08 ee       	ldi	r16, 0xE8	; 232
 b4c:	10 e0       	ldi	r17, 0x00	; 0
 b4e:	f8 01       	movw	r30, r16
 b50:	80 81       	ld	r24, Z
 b52:	87 7f       	andi	r24, 0xF7	; 247
 b54:	80 83       	st	Z, r24

	USB_Device_GetSerialString(SignatureDescriptor.UnicodeString);

	Endpoint_ClearSETUP();

	Endpoint_Write_Control_Stream_LE(&SignatureDescriptor, sizeof(SignatureDescriptor));
 b56:	6a e2       	ldi	r22, 0x2A	; 42
 b58:	70 e0       	ldi	r23, 0x00	; 0
 b5a:	ce 01       	movw	r24, r28
 b5c:	01 96       	adiw	r24, 0x01	; 1
 b5e:	ac db       	rcall	.-2216   	; 0x2b8 <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));
 b60:	f8 01       	movw	r30, r16
 b62:	80 81       	ld	r24, Z
 b64:	8b 77       	andi	r24, 0x7B	; 123
 b66:	80 83       	st	Z, r24
 b68:	4a c0       	rjmp	.+148    	; 0xbfe <__stack+0xff>
		USB_Device_GetInternalSerialDescriptor();
		return;
	}
	#endif

	if ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex,
 b6a:	ae 01       	movw	r20, r28
 b6c:	4f 5f       	subi	r20, 0xFF	; 255
 b6e:	5f 4f       	sbci	r21, 0xFF	; 255
 b70:	60 91 18 01 	lds	r22, 0x0118
 b74:	07 db       	rcall	.-2546   	; 0x184 <CALLBACK_USB_GetDescriptor>
 b76:	00 97       	sbiw	r24, 0x00	; 0
 b78:	09 f4       	brne	.+2      	; 0xb7c <__stack+0x7d>
 b7a:	41 c0       	rjmp	.+130    	; 0xbfe <__stack+0xff>
			 *  \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);
 b7c:	08 ee       	ldi	r16, 0xE8	; 232
 b7e:	10 e0       	ldi	r17, 0x00	; 0
 b80:	f8 01       	movw	r30, r16
 b82:	20 81       	ld	r18, Z
 b84:	27 7f       	andi	r18, 0xF7	; 247
 b86:	20 83       	st	Z, r18
	#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);
 b88:	bc 01       	movw	r22, r24
 b8a:	89 81       	ldd	r24, Y+1	; 0x01
 b8c:	9a 81       	ldd	r25, Y+2	; 0x02
 b8e:	92 dc       	rcall	.-1756   	; 0x4b4 <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));
 b90:	f8 01       	movw	r30, r16
 b92:	80 81       	ld	r24, Z
 b94:	8b 77       	andi	r24, 0x7B	; 123
 b96:	80 83       	st	Z, r24
 b98:	32 c0       	rjmp	.+100    	; 0xbfe <__stack+0xff>
					USB_Device_GetDescriptor();
				}

				break;
			case REQ_GetConfiguration:
				if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
 b9a:	30 38       	cpi	r19, 0x80	; 128
 b9c:	81 f5       	brne	.+96     	; 0xbfe <__stack+0xff>
			 *  \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);
 b9e:	e8 ee       	ldi	r30, 0xE8	; 232
 ba0:	f0 e0       	ldi	r31, 0x00	; 0
 ba2:	80 81       	ld	r24, Z
 ba4:	87 7f       	andi	r24, 0xF7	; 247
 ba6:	80 83       	st	Z, r24

static void USB_Device_GetConfiguration(void)
{
	Endpoint_ClearSETUP();

	Endpoint_Write_8(USB_Device_ConfigurationNumber);
 ba8:	80 91 0f 01 	lds	r24, 0x010F
			 *  \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;
 bac:	80 93 f1 00 	sts	0x00F1, r24
			 */
			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));
 bb0:	80 81       	ld	r24, Z
 bb2:	8e 77       	andi	r24, 0x7E	; 126
 bb4:	80 83       	st	Z, r24
	Endpoint_ClearIN();

	Endpoint_ClearStatusStage();
 bb6:	62 dd       	rcall	.-1340   	; 0x67c <Endpoint_ClearStatusStage>
 bb8:	22 c0       	rjmp	.+68     	; 0xbfe <__stack+0xff>
				if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
				  USB_Device_GetConfiguration();

				break;
			case REQ_SetConfiguration:
				if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
 bba:	31 11       	cpse	r19, r1
 bbc:	20 c0       	rjmp	.+64     	; 0xbfe <__stack+0xff>
}

static void USB_Device_SetConfiguration(void)
{
	#if defined(FIXED_NUM_CONFIGURATIONS)
	if ((uint8_t)USB_ControlRequest.wValue > FIXED_NUM_CONFIGURATIONS)
 bbe:	80 91 16 01 	lds	r24, 0x0116
 bc2:	82 30       	cpi	r24, 0x02	; 2
 bc4:	e0 f4       	brcc	.+56     	; 0xbfe <__stack+0xff>
			 *  \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);
 bc6:	e8 ee       	ldi	r30, 0xE8	; 232
 bc8:	f0 e0       	ldi	r31, 0x00	; 0
 bca:	80 81       	ld	r24, Z
 bcc:	87 7f       	andi	r24, 0xF7	; 247
 bce:	80 83       	st	Z, r24
	#endif
	#endif

	Endpoint_ClearSETUP();

	USB_Device_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
 bd0:	80 91 16 01 	lds	r24, 0x0116
 bd4:	80 93 0f 01 	sts	0x010F, r24

	Endpoint_ClearStatusStage();
 bd8:	51 dd       	rcall	.-1374   	; 0x67c <Endpoint_ClearStatusStage>

	if (USB_Device_ConfigurationNumber)
 bda:	80 91 0f 01 	lds	r24, 0x010F
 bde:	88 23       	and	r24, r24
 be0:	21 f0       	breq	.+8      	; 0xbea <__stack+0xeb>
	  USB_DeviceState = DEVICE_STATE_Configured;
 be2:	84 e0       	ldi	r24, 0x04	; 4
 be4:	80 93 13 01 	sts	0x0113, r24
 be8:	09 c0       	rjmp	.+18     	; 0xbfc <__stack+0xfd>
			}

			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));
 bea:	80 91 e3 00 	lds	r24, 0x00E3
	else
	  USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered;
 bee:	88 23       	and	r24, r24
 bf0:	14 f4       	brge	.+4      	; 0xbf6 <__stack+0xf7>
 bf2:	84 e0       	ldi	r24, 0x04	; 4
 bf4:	01 c0       	rjmp	.+2      	; 0xbf8 <__stack+0xf9>
 bf6:	81 e0       	ldi	r24, 0x01	; 1
 bf8:	80 93 13 01 	sts	0x0113, r24

	EVENT_USB_Device_ConfigurationChanged();
 bfc:	59 d0       	rcall	.+178    	; 0xcb0 <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);
 bfe:	80 91 e8 00 	lds	r24, 0x00E8
			default:
				break;
		}
	}

	if (Endpoint_IsSETUPReceived())
 c02:	83 ff       	sbrs	r24, 3
 c04:	16 c0       	rjmp	.+44     	; 0xc32 <__stack+0x133>
			 *  \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);
 c06:	e8 ee       	ldi	r30, 0xE8	; 232
 c08:	f0 e0       	ldi	r31, 0x00	; 0
 c0a:	80 81       	ld	r24, Z
 c0c:	87 7f       	andi	r24, 0xF7	; 247
 c0e:	80 83       	st	Z, r24
			 *  \ingroup Group_EndpointPacketManagement_AVR8
			 */
			static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;
			static inline void Endpoint_StallTransaction(void)
			{
				UECONX |= (1 << STALLRQ);
 c10:	eb ee       	ldi	r30, 0xEB	; 235
 c12:	f0 e0       	ldi	r31, 0x00	; 0
 c14:	80 81       	ld	r24, Z
 c16:	80 62       	ori	r24, 0x20	; 32
 c18:	80 83       	st	Z, r24
 c1a:	0b c0       	rjmp	.+22     	; 0xc32 <__stack+0x133>
{
	switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
	{
		#if !defined(NO_DEVICE_REMOTE_WAKEUP)
		case REQREC_DEVICE:
			if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_DeviceRemoteWakeup)
 c1c:	80 91 16 01 	lds	r24, 0x0116
 c20:	81 30       	cpi	r24, 0x01	; 1
 c22:	69 f7       	brne	.-38     	; 0xbfe <__stack+0xff>
 c24:	08 cf       	rjmp	.-496    	; 0xa36 <USB_Device_ProcessControlRequest+0xb2>

			break;
		#endif
		#if !defined(CONTROL_ONLY_DEVICE)
		case REQREC_ENDPOINT:
			if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_EndpointHalt)
 c26:	80 91 16 01 	lds	r24, 0x0116
 c2a:	88 23       	and	r24, r24
 c2c:	09 f4       	brne	.+2      	; 0xc30 <__stack+0x131>
 c2e:	0a cf       	rjmp	.-492    	; 0xa44 <USB_Device_ProcessControlRequest+0xc0>
 c30:	31 cf       	rjmp	.-414    	; 0xa94 <USB_Device_ProcessControlRequest+0x110>
	if (Endpoint_IsSETUPReceived())
	{
		Endpoint_ClearSETUP();
		Endpoint_StallTransaction();
	}
}
 c32:	aa 96       	adiw	r28, 0x2a	; 42
 c34:	0f b6       	in	r0, 0x3f	; 63
 c36:	f8 94       	cli
 c38:	de bf       	out	0x3e, r29	; 62
 c3a:	0f be       	out	0x3f, r0	; 63
 c3c:	cd bf       	out	0x3d, r28	; 61
 c3e:	df 91       	pop	r29
 c40:	cf 91       	pop	r28
 c42:	1f 91       	pop	r17
 c44:	0f 91       	pop	r16
 c46:	08 95       	ret

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

void USB_Event_Stub(void)
{
 c48:	08 95       	ret

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

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

#if defined(USB_CAN_BE_DEVICE)
static void USB_DeviceTask(void)
{
	if (USB_DeviceState == DEVICE_STATE_Unattached)
 c4c:	80 91 13 01 	lds	r24, 0x0113
 c50:	88 23       	and	r24, r24
 c52:	a1 f0       	breq	.+40     	; 0xc7c <USB_USBTask+0x32>
			 */
			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());
 c54:	c0 91 e9 00 	lds	r28, 0x00E9
 c58:	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;
 c5a:	80 91 ec 00 	lds	r24, 0x00EC
 c5e:	80 ff       	sbrs	r24, 0
 c60:	02 c0       	rjmp	.+4      	; 0xc66 <USB_USBTask+0x1c>
 c62:	80 e8       	ldi	r24, 0x80	; 128
 c64:	01 c0       	rjmp	.+2      	; 0xc68 <USB_USBTask+0x1e>
 c66:	80 e0       	ldi	r24, 0x00	; 0
			 */
			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());
 c68:	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);
 c6a:	10 92 e9 00 	sts	0x00E9, r1
			 *  \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);
 c6e:	80 91 e8 00 	lds	r24, 0x00E8

	uint8_t PrevEndpoint = Endpoint_GetCurrentEndpoint();

	Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);

	if (Endpoint_IsSETUPReceived())
 c72:	83 fd       	sbrc	r24, 3
	  USB_Device_ProcessControlRequest();
 c74:	87 de       	rcall	.-754    	; 0x984 <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);
 c76:	cf 70       	andi	r28, 0x0F	; 15
 c78:	c0 93 e9 00 	sts	0x00E9, r28
	#elif defined(USB_CAN_BE_HOST)
		USB_HostTask();
	#elif defined(USB_CAN_BE_DEVICE)
		USB_DeviceTask();
	#endif
}
 c7c:	cf 91       	pop	r28
 c7e:	08 95       	ret

00000c80 <SetupHardware>:

/** Configures the board hardware and chip peripherals for the demo's functionality. */
void SetupHardware(void)
{
	/* Disable watchdog if enabled by bootloader/fuses */
	MCUSR &= ~(1 << WDRF);
 c80:	84 b7       	in	r24, 0x34	; 52
 c82:	87 7f       	andi	r24, 0xF7	; 247
 c84:	84 bf       	out	0x34, r24	; 52
	wdt_disable();
 c86:	88 e1       	ldi	r24, 0x18	; 24
 c88:	0f b6       	in	r0, 0x3f	; 63
 c8a:	f8 94       	cli
 c8c:	80 93 60 00 	sts	0x0060, r24
 c90:	10 92 60 00 	sts	0x0060, r1
 c94:	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__ (
 c96:	90 e0       	ldi	r25, 0x00	; 0
 c98:	80 e8       	ldi	r24, 0x80	; 128
 c9a:	0f b6       	in	r0, 0x3f	; 63
 c9c:	f8 94       	cli
 c9e:	80 93 61 00 	sts	0x0061, r24
 ca2:	90 93 61 00 	sts	0x0061, r25
 ca6:	0f be       	out	0x3f, r0	; 63
	/* Disable clock division */
	clock_prescale_set(clock_div_1);

	/* Hardware Initialization */
	USB_Init();
 ca8:	8f cd       	rjmp	.-1250   	; 0x7c8 <USB_Init>
 caa:	08 95       	ret

00000cac <EVENT_USB_Device_Connect>:

/** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
 *  starts the library USB task to begin the enumeration and USB management process.
 */
void EVENT_USB_Device_Connect(void)
{
 cac:	08 95       	ret

00000cae <EVENT_USB_Device_Disconnect>:

/** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
 *  the status LEDs and stops the USB management and CDC management tasks.
 */
void EVENT_USB_Device_Disconnect(void)
{
 cae:	08 95       	ret

00000cb0 <EVENT_USB_Device_ConfigurationChanged>:
				uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);

				if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
				  return false;

				return Endpoint_ConfigureEndpoint_Prv(Number,
 cb0:	42 e0       	ldi	r20, 0x02	; 2
 cb2:	61 ec       	ldi	r22, 0xC1	; 193
 cb4:	82 e0       	ldi	r24, 0x02	; 2
 cb6:	7e dc       	rcall	.-1796   	; 0x5b4 <Endpoint_ConfigureEndpoint_Prv>
 cb8:	42 e1       	ldi	r20, 0x12	; 18
 cba:	61 e8       	ldi	r22, 0x81	; 129
 cbc:	83 e0       	ldi	r24, 0x03	; 3
 cbe:	7a dc       	rcall	.-1804   	; 0x5b4 <Endpoint_ConfigureEndpoint_Prv>
 cc0:	42 e1       	ldi	r20, 0x12	; 18
 cc2:	60 e8       	ldi	r22, 0x80	; 128
 cc4:	84 e0       	ldi	r24, 0x04	; 4
 cc6:	76 dc       	rcall	.-1812   	; 0x5b4 <Endpoint_ConfigureEndpoint_Prv>
	ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPADDR, EP_TYPE_INTERRUPT, CDC_NOTIFICATION_EPSIZE, 1);
	ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_TX_EPADDR, EP_TYPE_BULK, CDC_TXRX_EPSIZE, 1);
	ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_RX_EPADDR, EP_TYPE_BULK,  CDC_TXRX_EPSIZE, 1);

	/* Reset line encoding baud rate so that the host knows to send new values */
	LineEncoding.BaudRateBPS = 0;
 cc8:	10 92 00 01 	sts	0x0100, r1
 ccc:	10 92 01 01 	sts	0x0101, r1
 cd0:	10 92 02 01 	sts	0x0102, r1
 cd4:	10 92 03 01 	sts	0x0103, r1
 cd8:	08 95       	ret

00000cda <EVENT_USB_Device_ControlRequest>:
/** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
 *  the device from the USB host before passing along unhandled control requests to the library for processing
 *  internally.
 */
void EVENT_USB_Device_ControlRequest(void)
{
 cda:	cf 93       	push	r28
 cdc:	df 93       	push	r29
	/* Process CDC specific control requests */
	switch (USB_ControlRequest.bRequest)
 cde:	80 91 15 01 	lds	r24, 0x0115
 ce2:	81 32       	cpi	r24, 0x21	; 33
 ce4:	29 f0       	breq	.+10     	; 0xcf0 <EVENT_USB_Device_ControlRequest+0x16>
 ce6:	82 32       	cpi	r24, 0x22	; 34
 ce8:	39 f1       	breq	.+78     	; 0xd38 <EVENT_USB_Device_ControlRequest+0x5e>
 cea:	80 32       	cpi	r24, 0x20	; 32
 cec:	79 f5       	brne	.+94     	; 0xd4c <EVENT_USB_Device_ControlRequest+0x72>
 cee:	12 c0       	rjmp	.+36     	; 0xd14 <EVENT_USB_Device_ControlRequest+0x3a>
	{
		case CDC_REQ_GetLineEncoding:
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 cf0:	80 91 14 01 	lds	r24, 0x0114
 cf4:	81 3a       	cpi	r24, 0xA1	; 161
 cf6:	51 f5       	brne	.+84     	; 0xd4c <EVENT_USB_Device_ControlRequest+0x72>
			 *  \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);
 cf8:	c8 ee       	ldi	r28, 0xE8	; 232
 cfa:	d0 e0       	ldi	r29, 0x00	; 0
 cfc:	88 81       	ld	r24, Y
 cfe:	87 7f       	andi	r24, 0xF7	; 247
 d00:	88 83       	st	Y, r24
			{
				Endpoint_ClearSETUP();

				/* Write the line coding data to the control endpoint */
				Endpoint_Write_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
 d02:	67 e0       	ldi	r22, 0x07	; 7
 d04:	70 e0       	ldi	r23, 0x00	; 0
 d06:	80 e0       	ldi	r24, 0x00	; 0
 d08:	91 e0       	ldi	r25, 0x01	; 1
 d0a:	d6 da       	rcall	.-2644   	; 0x2b8 <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));
 d0c:	88 81       	ld	r24, Y
 d0e:	8b 77       	andi	r24, 0x7B	; 123
 d10:	88 83       	st	Y, r24
 d12:	1c c0       	rjmp	.+56     	; 0xd4c <EVENT_USB_Device_ControlRequest+0x72>
				Endpoint_ClearOUT();
			}

			break;
		case CDC_REQ_SetLineEncoding:
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 d14:	80 91 14 01 	lds	r24, 0x0114
 d18:	81 32       	cpi	r24, 0x21	; 33
 d1a:	c1 f4       	brne	.+48     	; 0xd4c <EVENT_USB_Device_ControlRequest+0x72>
			 *  \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);
 d1c:	c8 ee       	ldi	r28, 0xE8	; 232
 d1e:	d0 e0       	ldi	r29, 0x00	; 0
 d20:	88 81       	ld	r24, Y
 d22:	87 7f       	andi	r24, 0xF7	; 247
 d24:	88 83       	st	Y, r24
			{
				Endpoint_ClearSETUP();

				/* Read the line coding data in from the host into the global struct */
				Endpoint_Read_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
 d26:	67 e0       	ldi	r22, 0x07	; 7
 d28:	70 e0       	ldi	r23, 0x00	; 0
 d2a:	80 e0       	ldi	r24, 0x00	; 0
 d2c:	91 e0       	ldi	r25, 0x01	; 1
 d2e:	44 db       	rcall	.-2424   	; 0x3b8 <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));
 d30:	88 81       	ld	r24, Y
 d32:	8e 77       	andi	r24, 0x7E	; 126
 d34:	88 83       	st	Y, r24
 d36:	0a c0       	rjmp	.+20     	; 0xd4c <EVENT_USB_Device_ControlRequest+0x72>
				Endpoint_ClearIN();
			}

			break;
		case CDC_REQ_SetControlLineState:
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 d38:	80 91 14 01 	lds	r24, 0x0114
 d3c:	81 32       	cpi	r24, 0x21	; 33
 d3e:	31 f4       	brne	.+12     	; 0xd4c <EVENT_USB_Device_ControlRequest+0x72>
			 *  \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);
 d40:	e8 ee       	ldi	r30, 0xE8	; 232
 d42:	f0 e0       	ldi	r31, 0x00	; 0
 d44:	80 81       	ld	r24, Z
 d46:	87 7f       	andi	r24, 0xF7	; 247
 d48:	80 83       	st	Z, r24
			{
				Endpoint_ClearSETUP();
				Endpoint_ClearStatusStage();
 d4a:	98 dc       	rcall	.-1744   	; 0x67c <Endpoint_ClearStatusStage>
				*/
			}

			break;
	}
}
 d4c:	df 91       	pop	r29
 d4e:	cf 91       	pop	r28
 d50:	08 95       	ret

00000d52 <CDC_Task>:
	char*       ReportString    = NULL;
	uint8_t     JoyStatus_LCL   = Joystick_GetStatus();
	static bool ActionSent      = false;

	/* Device must be connected and configured for the task to run */
	if (USB_DeviceState != DEVICE_STATE_Configured)
 d52:	80 91 13 01 	lds	r24, 0x0113
 d56:	84 30       	cpi	r24, 0x04	; 4
 d58:	d1 f5       	brne	.+116    	; 0xdce <CDC_Task+0x7c>
	  return;

	/* Determine if a joystick action has occurred */
    ReportString = "TEST\r\n";
    ActionSent = false;
 d5a:	10 92 0e 01 	sts	0x010E, r1

	/* Flag management - Only allow one string to be sent per action */
	if ((ReportString != NULL) && (ActionSent == false) && LineEncoding.BaudRateBPS)
 d5e:	80 91 00 01 	lds	r24, 0x0100
 d62:	90 91 01 01 	lds	r25, 0x0101
 d66:	a0 91 02 01 	lds	r26, 0x0102
 d6a:	b0 91 03 01 	lds	r27, 0x0103
 d6e:	89 2b       	or	r24, r25
 d70:	8a 2b       	or	r24, r26
 d72:	8b 2b       	or	r24, r27
 d74:	01 f1       	breq	.+64     	; 0xdb6 <CDC_Task+0x64>
	{
		ActionSent = true;
 d76:	81 e0       	ldi	r24, 0x01	; 1
 d78:	80 93 0e 01 	sts	0x010E, 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);
 d7c:	83 e0       	ldi	r24, 0x03	; 3
 d7e:	80 93 e9 00 	sts	0x00E9, r24

		/* Select the Serial Tx Endpoint */
		Endpoint_SelectEndpoint(CDC_TX_EPADDR);

		/* Write the String to the Endpoint */
		Endpoint_Write_Stream_LE(ReportString, strlen(ReportString), NULL);
 d82:	40 e0       	ldi	r20, 0x00	; 0
 d84:	50 e0       	ldi	r21, 0x00	; 0
 d86:	66 e0       	ldi	r22, 0x06	; 6
 d88:	70 e0       	ldi	r23, 0x00	; 0
 d8a:	87 e0       	ldi	r24, 0x07	; 7
 d8c:	91 e0       	ldi	r25, 0x01	; 1
 d8e:	37 da       	rcall	.-2962   	; 0x1fe <Endpoint_Write_Stream_LE>
			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);
 d90:	20 91 f3 00 	lds	r18, 0x00F3
 d94:	80 91 f2 00 	lds	r24, 0x00F2
			 */
			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));
 d98:	e8 ee       	ldi	r30, 0xE8	; 232
 d9a:	f0 e0       	ldi	r31, 0x00	; 0
 d9c:	90 81       	ld	r25, Z
 d9e:	9e 77       	andi	r25, 0x7E	; 126
 da0:	90 83       	st	Z, r25
			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);
 da2:	90 e0       	ldi	r25, 0x00	; 0
 da4:	92 2b       	or	r25, r18
		/* Finalize the stream transfer to send the last packet */
		Endpoint_ClearIN();

		/* If the last packet filled the endpoint, send an empty packet to release the buffer on
		 * the receiver (otherwise all data will be cached until a non-full packet is received) */
		if (IsFull)
 da6:	40 97       	sbiw	r24, 0x10	; 16
 da8:	31 f4       	brne	.+12     	; 0xdb6 <CDC_Task+0x64>
		{
			/* Wait until the endpoint is ready for another packet */
			Endpoint_WaitUntilReady();
 daa:	8c dc       	rcall	.-1768   	; 0x6c4 <Endpoint_WaitUntilReady>
			 */
			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));
 dac:	e8 ee       	ldi	r30, 0xE8	; 232
 dae:	f0 e0       	ldi	r31, 0x00	; 0
 db0:	80 81       	ld	r24, Z
 db2:	8e 77       	andi	r24, 0x7E	; 126
 db4:	80 83       	st	Z, 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);
 db6:	84 e0       	ldi	r24, 0x04	; 4
 db8:	80 93 e9 00 	sts	0x00E9, r24
			 *  \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);
 dbc:	80 91 e8 00 	lds	r24, 0x00E8

	/* Select the Serial Rx Endpoint */
	Endpoint_SelectEndpoint(CDC_RX_EPADDR);

	/* Throw away any received data from the host */
	if (Endpoint_IsOUTReceived())
 dc0:	82 ff       	sbrs	r24, 2
 dc2:	05 c0       	rjmp	.+10     	; 0xdce <CDC_Task+0x7c>
			 */
			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));
 dc4:	e8 ee       	ldi	r30, 0xE8	; 232
 dc6:	f0 e0       	ldi	r31, 0x00	; 0
 dc8:	80 81       	ld	r24, Z
 dca:	8b 77       	andi	r24, 0x7B	; 123
 dcc:	80 83       	st	Z, r24
 dce:	08 95       	ret

00000dd0 <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();
 dd0:	57 df       	rcall	.-338    	; 0xc80 <SetupHardware>
			static inline void GlobalInterruptEnable(void)
			{
				GCC_MEMORY_BARRIER();

				#if (ARCH == ARCH_AVR8)
				sei();
 dd2:	78 94       	sei
	GlobalInterruptEnable();
	for (;;)
	{
		CDC_Task();
 dd4:	be df       	rcall	.-132    	; 0xd52 <CDC_Task>
		USB_USBTask();
 dd6:	39 df       	rcall	.-398    	; 0xc4a <USB_USBTask>
 dd8:	fd cf       	rjmp	.-6      	; 0xdd4 <main+0x4>

00000dda <__tablejump2__>:
 dda:	ee 0f       	add	r30, r30
 ddc:	ff 1f       	adc	r31, r31

00000dde <__tablejump__>:
 dde:	05 90       	lpm	r0, Z+
 de0:	f4 91       	lpm	r31, Z
 de2:	e0 2d       	mov	r30, r0
 de4:	09 94       	ijmp

00000de6 <_exit>:
 de6:	f8 94       	cli

00000de8 <__stop_program>:
 de8:	ff cf       	rjmp	.-2      	; 0xde8 <__stop_program>
