USB_gadget.elf:     format de fichier elf32-avr
  
  Sections :
  Idx Nom           Taille    VMA       LMA       Fich off  Algn
    0 .data         0000001c  00800100  00000ff0  00001084  2**0
                    CONTENTS, ALLOC, LOAD, DATA
    1 .text         00000ff0  00000000  00000000  00000094  2**1
                    CONTENTS, ALLOC, LOAD, READONLY, CODE
    2 .bss          00000124  0080011c  0080011c  000010a0  2**0
                    ALLOC
    3 .comment      00000011  00000000  00000000  000010a0  2**0
                    CONTENTS, READONLY
    4 .note.gnu.avr.deviceinfo 00000040  00000000  00000000  000010b4  2**2
                    CONTENTS, READONLY
    5 .debug_aranges 00000308  00000000  00000000  000010f4  2**0
                    CONTENTS, READONLY, DEBUGGING
    6 .debug_info   00005bcc  00000000  00000000  000013fc  2**0
                    CONTENTS, READONLY, DEBUGGING
    7 .debug_abbrev 0000158c  00000000  00000000  00006fc8  2**0
                    CONTENTS, READONLY, DEBUGGING
    8 .debug_line   000036c6  00000000  00000000  00008554  2**0
                    CONTENTS, READONLY, DEBUGGING
    9 .debug_frame  000008cc  00000000  00000000  0000bc1c  2**2
                    CONTENTS, READONLY, DEBUGGING
   10 .debug_str    0000246c  00000000  00000000  0000c4e8  2**0
                    CONTENTS, READONLY, DEBUGGING
   11 .debug_loc    00003926  00000000  00000000  0000e954  2**0
                    CONTENTS, READONLY, DEBUGGING
   12 .debug_ranges 00000420  00000000  00000000  0001227a  2**0
                    CONTENTS, READONLY, DEBUGGING
  
  Déassemblage de la section .text :
  
  00000000 <__vectors>:
     0:	88 c0       	rjmp	.+272    	; 0x112 <__ctors_end>
     2:	00 00       	nop
     4:	a1 c0       	rjmp	.+322    	; 0x148 <__bad_interrupt>
     6:	00 00       	nop
     8:	9f c0       	rjmp	.+318    	; 0x148 <__bad_interrupt>
     a:	00 00       	nop
     c:	9d c0       	rjmp	.+314    	; 0x148 <__bad_interrupt>
     e:	00 00       	nop
    10:	9b c0       	rjmp	.+310    	; 0x148 <__bad_interrupt>
    12:	00 00       	nop
    14:	99 c0       	rjmp	.+306    	; 0x148 <__bad_interrupt>
    16:	00 00       	nop
    18:	97 c0       	rjmp	.+302    	; 0x148 <__bad_interrupt>
    1a:	00 00       	nop
    1c:	95 c0       	rjmp	.+298    	; 0x148 <__bad_interrupt>
    1e:	00 00       	nop
    20:	93 c0       	rjmp	.+294    	; 0x148 <__bad_interrupt>
    22:	00 00       	nop
    24:	91 c0       	rjmp	.+290    	; 0x148 <__bad_interrupt>
    26:	00 00       	nop
    28:	8f c0       	rjmp	.+286    	; 0x148 <__bad_interrupt>
    2a:	00 00       	nop
    2c:	f9 c3       	rjmp	.+2034   	; 0x820 <__vector_11>
    2e:	00 00       	nop
    30:	9c c4       	rjmp	.+2360   	; 0x96a <__vector_12>
    32:	00 00       	nop
    34:	89 c0       	rjmp	.+274    	; 0x148 <__bad_interrupt>
    36:	00 00       	nop
    38:	87 c0       	rjmp	.+270    	; 0x148 <__bad_interrupt>
    3a:	00 00       	nop
    3c:	85 c0       	rjmp	.+266    	; 0x148 <__bad_interrupt>
    3e:	00 00       	nop
    40:	83 c0       	rjmp	.+262    	; 0x148 <__bad_interrupt>
    42:	00 00       	nop
    44:	81 c0       	rjmp	.+258    	; 0x148 <__bad_interrupt>
    46:	00 00       	nop
    48:	7f c0       	rjmp	.+254    	; 0x148 <__bad_interrupt>
    4a:	00 00       	nop
    4c:	7d c0       	rjmp	.+250    	; 0x148 <__bad_interrupt>
    4e:	00 00       	nop
    50:	7b c0       	rjmp	.+246    	; 0x148 <__bad_interrupt>
    52:	00 00       	nop
    54:	79 c0       	rjmp	.+242    	; 0x148 <__bad_interrupt>
    56:	00 00       	nop
    58:	77 c0       	rjmp	.+238    	; 0x148 <__bad_interrupt>
    5a:	00 00       	nop
    5c:	6a c1       	rjmp	.+724    	; 0x332 <__vector_23>
    5e:	00 00       	nop
    60:	73 c0       	rjmp	.+230    	; 0x148 <__bad_interrupt>
    62:	00 00       	nop
    64:	71 c0       	rjmp	.+226    	; 0x148 <__bad_interrupt>
    66:	00 00       	nop
    68:	6f c0       	rjmp	.+222    	; 0x148 <__bad_interrupt>
    6a:	00 00       	nop
    6c:	6d c0       	rjmp	.+218    	; 0x148 <__bad_interrupt>
    6e:	00 00       	nop
    70:	6b c0       	rjmp	.+214    	; 0x148 <__bad_interrupt>
    72:	00 00       	nop
  
  00000074 <ProductString>:
    74:	2e 03 4c 00 55 00 46 00 41 00 20 00 55 00 53 00     ..L.U.F.A. .U.S.
    84:	42 00 2d 00 52 00 53 00 32 00 33 00 32 00 20 00     B.-.R.S.2.3.2. .
    94:	41 00 64 00 61 00 70 00 74 00 65 00 72 00 00 00     A.d.a.p.t.e.r...
  
  000000a4 <ManufacturerString>:
    a4:	18 03 44 00 65 00 61 00 6e 00 20 00 43 00 61 00     ..D.e.a.n. .C.a.
    b4:	6d 00 65 00 72 00 61 00 00 00                       m.e.r.a...
  
  000000be <LanguageString>:
    be:	04 03 09 04                                         ....
  
  000000c2 <ConfigurationDescriptor>:
    c2:	09 02 3e 00 02 01 00 c0 32 09 04 00 00 01 02 02     ..>.....2.......
    d2:	01 00 05 24 00 10 01 04 24 02 06 05 24 06 00 01     ...$....$...$...
    e2:	07 05 82 03 08 00 ff 09 04 01 00 02 0a 00 00 00     ................
    f2:	07 05 04 02 10 00 05 07 05 83 02 10 00 05           ..............
  
  00000100 <DeviceDescriptor>:
   100:	12 01 10 01 02 00 00 08 eb 03 4b 20 01 00 01 02     ..........K ....
   110:	dc 01                                               ..
  
  00000112 <__ctors_end>:
   112:	11 24       	eor	r1, r1
   114:	1f be       	out	0x3f, r1	; 63
   116:	cf ef       	ldi	r28, 0xFF	; 255
   118:	d2 e0       	ldi	r29, 0x02	; 2
   11a:	de bf       	out	0x3e, r29	; 62
   11c:	cd bf       	out	0x3d, r28	; 61
  
  0000011e <__do_copy_data>:
   11e:	11 e0       	ldi	r17, 0x01	; 1
   120:	a0 e0       	ldi	r26, 0x00	; 0
   122:	b1 e0       	ldi	r27, 0x01	; 1
   124:	e0 ef       	ldi	r30, 0xF0	; 240
   126:	ff e0       	ldi	r31, 0x0F	; 15
   128:	02 c0       	rjmp	.+4      	; 0x12e <__do_copy_data+0x10>
   12a:	05 90       	lpm	r0, Z+
   12c:	0d 92       	st	X+, r0
   12e:	ac 31       	cpi	r26, 0x1C	; 28
   130:	b1 07       	cpc	r27, r17
   132:	d9 f7       	brne	.-10     	; 0x12a <__do_copy_data+0xc>
  
  00000134 <__do_clear_bss>:
   134:	22 e0       	ldi	r18, 0x02	; 2
   136:	ac e1       	ldi	r26, 0x1C	; 28
   138:	b1 e0       	ldi	r27, 0x01	; 1
   13a:	01 c0       	rjmp	.+2      	; 0x13e <.do_clear_bss_start>
  
  0000013c <.do_clear_bss_loop>:
   13c:	1d 92       	st	X+, r1
  
  0000013e <.do_clear_bss_start>:
   13e:	a0 34       	cpi	r26, 0x40	; 64
   140:	b2 07       	cpc	r27, r18
   142:	e1 f7       	brne	.-8      	; 0x13c <.do_clear_bss_loop>
   144:	5a d0       	rcall	.+180    	; 0x1fa <main>
   146:	52 c7       	rjmp	.+3748   	; 0xfec <_exit>
  
  00000148 <__bad_interrupt>:
   148:	5b cf       	rjmp	.-330    	; 0x0 <__vectors>
  
  0000014a <LEDs_SetAllLEDs>:
  				PORTD |= LEDMask;
  			}
  
  			static inline void LEDs_SetAllLEDs(const uint8_t LEDMask)
  			{
  				PORTD = ((PORTD | LEDS_ALL_LEDS) & ~LEDMask);
   14a:	9b b1       	in	r25, 0x0b	; 11
   14c:	80 95       	com	r24
   14e:	90 63       	ori	r25, 0x30	; 48
   150:	89 23       	and	r24, r25
   152:	8b b9       	out	0x0b, r24	; 11
   154:	08 95       	ret
  
  00000156 <RingBuffer_Insert>:
  		static inline void RingBuffer_Insert(RingBuffer_t* Buffer,
  		                                     const uint8_t Data) ATTR_NON_NULL_PTR_ARG(1);
  		static inline void RingBuffer_Insert(RingBuffer_t* Buffer,
  		                                     const uint8_t Data)
  		{
  			GCC_FORCE_POINTER_ACCESS(Buffer);
   156:	fc 01       	movw	r30, r24
  
  			*Buffer->In = Data;
   158:	a0 81       	ld	r26, Z
   15a:	b1 81       	ldd	r27, Z+1	; 0x01
   15c:	6c 93       	st	X, r22
  
  			if (++Buffer->In == Buffer->End)
   15e:	80 81       	ld	r24, Z
   160:	91 81       	ldd	r25, Z+1	; 0x01
   162:	01 96       	adiw	r24, 0x01	; 1
   164:	91 83       	std	Z+1, r25	; 0x01
   166:	80 83       	st	Z, r24
   168:	26 81       	ldd	r18, Z+6	; 0x06
   16a:	37 81       	ldd	r19, Z+7	; 0x07
   16c:	82 17       	cp	r24, r18
   16e:	93 07       	cpc	r25, r19
   170:	21 f4       	brne	.+8      	; 0x17a <RingBuffer_Insert+0x24>
  			  Buffer->In = Buffer->Start;
   172:	84 81       	ldd	r24, Z+4	; 0x04
   174:	95 81       	ldd	r25, Z+5	; 0x05
   176:	91 83       	std	Z+1, r25	; 0x01
   178:	80 83       	st	Z, r24
  			static inline uint_reg_t GetGlobalInterruptMask(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				return SREG;
   17a:	2f b7       	in	r18, 0x3f	; 63
  			static inline void GlobalInterruptDisable(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				cli();
   17c:	f8 94       	cli
  
  			uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
  			GlobalInterruptDisable();
  
  			Buffer->Count++;
   17e:	82 85       	ldd	r24, Z+10	; 0x0a
   180:	93 85       	ldd	r25, Z+11	; 0x0b
   182:	01 96       	adiw	r24, 0x01	; 1
   184:	93 87       	std	Z+11, r25	; 0x0b
   186:	82 87       	std	Z+10, r24	; 0x0a
  			static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				SREG = GlobalIntState;
   188:	2f bf       	out	0x3f, r18	; 63
  				  __builtin_csrf(AVR32_SR_GM_OFFSET);
  				#elif (ARCH == ARCH_XMEGA)
  				SREG = GlobalIntState;
  				#endif
  
  				GCC_MEMORY_BARRIER();
   18a:	08 95       	ret
  
  0000018c <RingBuffer_Remove>:
  		 *  \return Next data element stored in the buffer.
  		 */
  		static inline uint8_t RingBuffer_Remove(RingBuffer_t* Buffer) ATTR_NON_NULL_PTR_ARG(1);
  		static inline uint8_t RingBuffer_Remove(RingBuffer_t* Buffer)
  		{
  			GCC_FORCE_POINTER_ACCESS(Buffer);
   18c:	fc 01       	movw	r30, r24
  
  			uint8_t Data = *Buffer->Out;
   18e:	a2 81       	ldd	r26, Z+2	; 0x02
   190:	b3 81       	ldd	r27, Z+3	; 0x03
   192:	8d 91       	ld	r24, X+
  
  			if (++Buffer->Out == Buffer->End)
   194:	b3 83       	std	Z+3, r27	; 0x03
   196:	a2 83       	std	Z+2, r26	; 0x02
   198:	26 81       	ldd	r18, Z+6	; 0x06
   19a:	37 81       	ldd	r19, Z+7	; 0x07
   19c:	a2 17       	cp	r26, r18
   19e:	b3 07       	cpc	r27, r19
   1a0:	21 f4       	brne	.+8      	; 0x1aa <RingBuffer_Remove+0x1e>
  			  Buffer->Out = Buffer->Start;
   1a2:	24 81       	ldd	r18, Z+4	; 0x04
   1a4:	35 81       	ldd	r19, Z+5	; 0x05
   1a6:	33 83       	std	Z+3, r19	; 0x03
   1a8:	22 83       	std	Z+2, r18	; 0x02
  			static inline uint_reg_t GetGlobalInterruptMask(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				return SREG;
   1aa:	9f b7       	in	r25, 0x3f	; 63
  			static inline void GlobalInterruptDisable(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				cli();
   1ac:	f8 94       	cli
  
  			uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
  			GlobalInterruptDisable();
  
  			Buffer->Count--;
   1ae:	22 85       	ldd	r18, Z+10	; 0x0a
   1b0:	33 85       	ldd	r19, Z+11	; 0x0b
   1b2:	21 50       	subi	r18, 0x01	; 1
   1b4:	31 09       	sbc	r19, r1
   1b6:	33 87       	std	Z+11, r19	; 0x0b
   1b8:	22 87       	std	Z+10, r18	; 0x0a
  			static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				SREG = GlobalIntState;
   1ba:	9f bf       	out	0x3f, r25	; 63
  
  			SetGlobalInterruptMask(CurrentGlobalInt);
  
  			return Data;
  		}
   1bc:	08 95       	ret
  
  000001be <SetupHardware>:
  /** Configures the board hardware and chip peripherals for the demo's functionality. */
  void SetupHardware(void)
  {
  #if (ARCH == ARCH_AVR8)
  	/* Disable watchdog if enabled by bootloader/fuses */
  	MCUSR &= ~(1 << WDRF);
   1be:	84 b7       	in	r24, 0x34	; 52
   1c0:	87 7f       	andi	r24, 0xF7	; 247
   1c2:	84 bf       	out	0x34, r24	; 52
  		);
  	}
  	else
  	{
          uint8_t register temp_reg;
  		__asm__ __volatile__ (
   1c4:	0f b6       	in	r0, 0x3f	; 63
   1c6:	f8 94       	cli
   1c8:	a8 95       	wdr
   1ca:	80 91 60 00 	lds	r24, 0x0060
   1ce:	88 61       	ori	r24, 0x18	; 24
   1d0:	80 93 60 00 	sts	0x0060, r24
   1d4:	10 92 60 00 	sts	0x0060, r1
   1d8:	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__ (
   1da:	90 e0       	ldi	r25, 0x00	; 0
   1dc:	80 e8       	ldi	r24, 0x80	; 128
   1de:	0f b6       	in	r0, 0x3f	; 63
   1e0:	f8 94       	cli
   1e2:	80 93 61 00 	sts	0x0061, r24
   1e6:	90 93 61 00 	sts	0x0061, r25
   1ea:	0f be       	out	0x3f, r0	; 63
  
  		/* Inline Functions: */
  		#if !defined(__DOXYGEN__)
  			static inline void LEDs_Init(void)
  			{
  				DDRD  |= LEDS_ALL_LEDS;
   1ec:	8a b1       	in	r24, 0x0a	; 10
   1ee:	80 63       	ori	r24, 0x30	; 48
   1f0:	8a b9       	out	0x0a, r24	; 10
  				PORTD |= LEDS_ALL_LEDS;
   1f2:	8b b1       	in	r24, 0x0b	; 11
   1f4:	80 63       	ori	r24, 0x30	; 48
   1f6:	8b b9       	out	0x0b, r24	; 11
  	clock_prescale_set(clock_div_1);
  #endif
  
  	/* Hardware Initialization */
  	LEDs_Init();
  	USB_Init();
   1f8:	04 c3       	rjmp	.+1544   	; 0x802 <USB_Init>
  
  000001fa <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();
   1fa:	e1 df       	rcall	.-62     	; 0x1be <SetupHardware>
  		                                         const uint16_t Size) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
  		static inline void RingBuffer_InitBuffer(RingBuffer_t* Buffer,
  		                                         uint8_t* const DataPtr,
  		                                         const uint16_t Size)
  		{
  			GCC_FORCE_POINTER_ACCESS(Buffer);
   1fc:	e8 e2       	ldi	r30, 0x28	; 40
   1fe:	f2 e0       	ldi	r31, 0x02	; 2
  			static inline uint_reg_t GetGlobalInterruptMask(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				return SREG;
   200:	4f b7       	in	r20, 0x3f	; 63
  			static inline void GlobalInterruptDisable(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				cli();
   202:	f8 94       	cli
  
  			uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
  			GlobalInterruptDisable();
  
  			Buffer->In     = DataPtr;
   204:	88 ea       	ldi	r24, 0xA8	; 168
   206:	91 e0       	ldi	r25, 0x01	; 1
   208:	91 83       	std	Z+1, r25	; 0x01
   20a:	80 83       	st	Z, r24
  			Buffer->Out    = DataPtr;
   20c:	93 83       	std	Z+3, r25	; 0x03
   20e:	82 83       	std	Z+2, r24	; 0x02
  			Buffer->Start  = &DataPtr[0];
   210:	95 83       	std	Z+5, r25	; 0x05
   212:	84 83       	std	Z+4, r24	; 0x04
  			Buffer->End    = &DataPtr[Size];
   214:	88 e2       	ldi	r24, 0x28	; 40
   216:	92 e0       	ldi	r25, 0x02	; 2
   218:	97 83       	std	Z+7, r25	; 0x07
   21a:	86 83       	std	Z+6, r24	; 0x06
  			Buffer->Size   = Size;
   21c:	20 e8       	ldi	r18, 0x80	; 128
   21e:	30 e0       	ldi	r19, 0x00	; 0
   220:	31 87       	std	Z+9, r19	; 0x09
   222:	20 87       	std	Z+8, r18	; 0x08
  			Buffer->Count  = 0;
   224:	13 86       	std	Z+11, r1	; 0x0b
   226:	12 86       	std	Z+10, r1	; 0x0a
  			static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				SREG = GlobalIntState;
   228:	4f bf       	out	0x3f, r20	; 63
  		                                         const uint16_t Size) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
  		static inline void RingBuffer_InitBuffer(RingBuffer_t* Buffer,
  		                                         uint8_t* const DataPtr,
  		                                         const uint16_t Size)
  		{
  			GCC_FORCE_POINTER_ACCESS(Buffer);
   22a:	ec e9       	ldi	r30, 0x9C	; 156
   22c:	f1 e0       	ldi	r31, 0x01	; 1
  			static inline uint_reg_t GetGlobalInterruptMask(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				return SREG;
   22e:	4f b7       	in	r20, 0x3f	; 63
  			static inline void GlobalInterruptDisable(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				cli();
   230:	f8 94       	cli
  
  			uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
  			GlobalInterruptDisable();
  
  			Buffer->In     = DataPtr;
   232:	8c e1       	ldi	r24, 0x1C	; 28
   234:	91 e0       	ldi	r25, 0x01	; 1
   236:	91 83       	std	Z+1, r25	; 0x01
   238:	80 83       	st	Z, r24
  			Buffer->Out    = DataPtr;
   23a:	93 83       	std	Z+3, r25	; 0x03
   23c:	82 83       	std	Z+2, r24	; 0x02
  			Buffer->Start  = &DataPtr[0];
   23e:	95 83       	std	Z+5, r25	; 0x05
   240:	84 83       	std	Z+4, r24	; 0x04
  			Buffer->End    = &DataPtr[Size];
   242:	8c e9       	ldi	r24, 0x9C	; 156
   244:	91 e0       	ldi	r25, 0x01	; 1
   246:	97 83       	std	Z+7, r25	; 0x07
   248:	86 83       	std	Z+6, r24	; 0x06
  			Buffer->Size   = Size;
   24a:	31 87       	std	Z+9, r19	; 0x09
   24c:	20 87       	std	Z+8, r18	; 0x08
  			Buffer->Count  = 0;
   24e:	13 86       	std	Z+11, r1	; 0x0b
   250:	12 86       	std	Z+10, r1	; 0x0a
  			static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				SREG = GlobalIntState;
   252:	4f bf       	out	0x3f, r20	; 63
  
  	RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data));
  	RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data));
  
  	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
   254:	80 e2       	ldi	r24, 0x20	; 32
   256:	79 df       	rcall	.-270    	; 0x14a <LEDs_SetAllLEDs>
  			static inline void GlobalInterruptEnable(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				sei();
   258:	78 94       	sei
  			static inline uint_reg_t GetGlobalInterruptMask(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				return SREG;
   25a:	8f b7       	in	r24, 0x3f	; 63
  			static inline void GlobalInterruptDisable(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				cli();
   25c:	f8 94       	cli
  			uint16_t Count;
  
  			uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
  			GlobalInterruptDisable();
  
  			Count = Buffer->Count;
   25e:	20 91 32 02 	lds	r18, 0x0232
   262:	30 91 33 02 	lds	r19, 0x0233
  			static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				SREG = GlobalIntState;
   266:	8f bf       	out	0x3f, r24	; 63
  	GlobalInterruptEnable();
  
  	for (;;)
  	{
  		/* Only try to read in bytes from the CDC interface if the transmit buffer is not full */
  		if (!(RingBuffer_IsFull(&USBtoUSART_Buffer)))
   268:	80 91 30 02 	lds	r24, 0x0230
   26c:	90 91 31 02 	lds	r25, 0x0231
   270:	28 17       	cp	r18, r24
   272:	39 07       	cpc	r19, r25
   274:	49 f0       	breq	.+18     	; 0x288 <main+0x8e>
  		{
  			int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
   276:	80 e0       	ldi	r24, 0x00	; 0
   278:	91 e0       	ldi	r25, 0x01	; 1
   27a:	ba d5       	rcall	.+2932   	; 0xdf0 <CDC_Device_ReceiveByte>
  
  			/* Store received byte into the USART transmit buffer */
  			if (!(ReceivedByte < 0))
   27c:	97 fd       	sbrc	r25, 7
   27e:	04 c0       	rjmp	.+8      	; 0x288 <main+0x8e>
  			  RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);
   280:	68 2f       	mov	r22, r24
   282:	88 e2       	ldi	r24, 0x28	; 40
   284:	92 e0       	ldi	r25, 0x02	; 2
   286:	67 df       	rcall	.-306    	; 0x156 <RingBuffer_Insert>
  			static inline uint_reg_t GetGlobalInterruptMask(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				return SREG;
   288:	2f b7       	in	r18, 0x3f	; 63
  			static inline void GlobalInterruptDisable(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				cli();
   28a:	f8 94       	cli
   28c:	80 91 a6 01 	lds	r24, 0x01A6
   290:	90 91 a7 01 	lds	r25, 0x01A7
  			static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				SREG = GlobalIntState;
   294:	2f bf       	out	0x3f, r18	; 63
  		}
  
  		uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
  		if (BufferCount)
   296:	00 97       	sbiw	r24, 0x00	; 0
   298:	29 f4       	brne	.+10     	; 0x2a4 <main+0xaa>
  			 *  \return Boolean \c true if a character can be queued for transmission immediately, \c false otherwise.
  			 */
  			static inline bool Serial_IsSendReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
  			static inline bool Serial_IsSendReady(void)
  			{
  				return ((UCSR1A & (1 << UDRE1)) ? true : false);
   29a:	80 91 c8 00 	lds	r24, 0x00C8
  				}
  			}
  		}
  
  		/* Load the next byte from the USART transmit buffer into the USART if transmit buffer space is available */
  		if (Serial_IsSendReady() && !(RingBuffer_IsEmpty(&USBtoUSART_Buffer)))
   29e:	85 fd       	sbrc	r24, 5
   2a0:	21 c0       	rjmp	.+66     	; 0x2e4 <main+0xea>
   2a2:	32 c0       	rjmp	.+100    	; 0x308 <__stack+0x9>
  			 */
  			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);
   2a4:	20 91 01 01 	lds	r18, 0x0101
   2a8:	2f 70       	andi	r18, 0x0F	; 15
   2aa:	20 93 e9 00 	sts	0x00E9, r18
  			 *  \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);
   2ae:	20 91 e8 00 	lds	r18, 0x00E8
  		{
  			Endpoint_SelectEndpoint(VirtualSerial_CDC_Interface.Config.DataINEndpoint.Address);
  
  			/* Check if a packet is already enqueued to the host - if so, we shouldn't try to send more data
  			 * until it completes as there is a chance nothing is listening and a lengthy timeout could occur */
  			if (Endpoint_IsINReady())
   2b2:	20 ff       	sbrs	r18, 0
   2b4:	f2 cf       	rjmp	.-28     	; 0x29a <main+0xa0>
  			{
  				/* Never send more than one bank size less one byte to the host at a time, so that we don't block
  				 * while a Zero Length Packet (ZLP) to terminate the transfer is sent if the host isn't listening */
  				uint8_t BytesToSend = MIN(BufferCount, (CDC_TXRX_EPSIZE - 1));
   2b6:	80 31       	cpi	r24, 0x10	; 16
   2b8:	91 05       	cpc	r25, r1
   2ba:	10 f0       	brcs	.+4      	; 0x2c0 <main+0xc6>
   2bc:	8f e0       	ldi	r24, 0x0F	; 15
   2be:	90 e0       	ldi	r25, 0x00	; 0
   2c0:	c8 2f       	mov	r28, r24
  		 *  \return Next data element stored in the buffer.
  		 */
  		static inline uint8_t RingBuffer_Peek(RingBuffer_t* const Buffer) ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(1);
  		static inline uint8_t RingBuffer_Peek(RingBuffer_t* const Buffer)
  		{
  			return *Buffer->Out;
   2c2:	e0 91 9e 01 	lds	r30, 0x019E
   2c6:	f0 91 9f 01 	lds	r31, 0x019F
  
  				/* Read bytes from the USART receive buffer into the USB IN endpoint */
  				while (BytesToSend--)
  				{
  					/* Try to send the next byte of data to the host, abort if there is an error without dequeuing */
  					if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,
   2ca:	60 81       	ld	r22, Z
   2cc:	80 e0       	ldi	r24, 0x00	; 0
   2ce:	91 e0       	ldi	r25, 0x01	; 1
   2d0:	27 d5       	rcall	.+2638   	; 0xd20 <CDC_Device_SendByte>
   2d2:	c1 50       	subi	r28, 0x01	; 1
   2d4:	81 11       	cpse	r24, r1
   2d6:	e1 cf       	rjmp	.-62     	; 0x29a <main+0xa0>
  					{
  						break;
  					}
  
  					/* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
  					RingBuffer_Remove(&USARTtoUSB_Buffer);
   2d8:	8c e9       	ldi	r24, 0x9C	; 156
   2da:	91 e0       	ldi	r25, 0x01	; 1
   2dc:	57 df       	rcall	.-338    	; 0x18c <RingBuffer_Remove>
  				/* Never send more than one bank size less one byte to the host at a time, so that we don't block
  				 * while a Zero Length Packet (ZLP) to terminate the transfer is sent if the host isn't listening */
  				uint8_t BytesToSend = MIN(BufferCount, (CDC_TXRX_EPSIZE - 1));
  
  				/* Read bytes from the USART receive buffer into the USB IN endpoint */
  				while (BytesToSend--)
   2de:	c1 11       	cpse	r28, r1
   2e0:	f0 cf       	rjmp	.-32     	; 0x2c2 <main+0xc8>
   2e2:	db cf       	rjmp	.-74     	; 0x29a <main+0xa0>
  			static inline uint_reg_t GetGlobalInterruptMask(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				return SREG;
   2e4:	2f b7       	in	r18, 0x3f	; 63
  			static inline void GlobalInterruptDisable(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				cli();
   2e6:	f8 94       	cli
  			uint16_t Count;
  
  			uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
  			GlobalInterruptDisable();
  
  			Count = Buffer->Count;
   2e8:	80 91 32 02 	lds	r24, 0x0232
   2ec:	90 91 33 02 	lds	r25, 0x0233
  			static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				SREG = GlobalIntState;
   2f0:	2f bf       	out	0x3f, r18	; 63
  				}
  			}
  		}
  
  		/* Load the next byte from the USART transmit buffer into the USART if transmit buffer space is available */
  		if (Serial_IsSendReady() && !(RingBuffer_IsEmpty(&USBtoUSART_Buffer)))
   2f2:	89 2b       	or	r24, r25
   2f4:	49 f0       	breq	.+18     	; 0x308 <__stack+0x9>
  		  Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer));
   2f6:	88 e2       	ldi	r24, 0x28	; 40
   2f8:	92 e0       	ldi	r25, 0x02	; 2
   2fa:	48 df       	rcall	.-368    	; 0x18c <RingBuffer_Remove>
   2fc:	90 91 c8 00 	lds	r25, 0x00C8
  			 *  \param[in] DataByte  Byte to transmit through the USART.
  			 */
  			static inline void Serial_SendByte(const char DataByte) ATTR_ALWAYS_INLINE;
  			static inline void Serial_SendByte(const char DataByte)
  			{
  				while (!(Serial_IsSendReady()));
   300:	95 ff       	sbrs	r25, 5
   302:	fc cf       	rjmp	.-8      	; 0x2fc <main+0x102>
  				UDR1 = DataByte;
   304:	80 93 ce 00 	sts	0x00CE, r24
  
  		CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
   308:	80 e0       	ldi	r24, 0x00	; 0
   30a:	91 e0       	ldi	r25, 0x01	; 1
   30c:	5c d5       	rcall	.+2744   	; 0xdc6 <CDC_Device_USBTask>
  		USB_USBTask();
   30e:	ca d4       	rcall	.+2452   	; 0xca4 <USB_USBTask>
  	}
   310:	a4 cf       	rjmp	.-184    	; 0x25a <main+0x60>
  
  00000312 <EVENT_USB_Device_Connect>:
  }
  
  /** Event handler for the library USB Connection event. */
  void EVENT_USB_Device_Connect(void)
  {
  	LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
   312:	80 e1       	ldi	r24, 0x10	; 16
   314:	1a cf       	rjmp	.-460    	; 0x14a <LEDs_SetAllLEDs>
  
  00000316 <EVENT_USB_Device_Disconnect>:
  }
  
  /** Event handler for the library USB Disconnection event. */
  void EVENT_USB_Device_Disconnect(void)
  {
  	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
   316:	80 e2       	ldi	r24, 0x20	; 32
   318:	18 cf       	rjmp	.-464    	; 0x14a <LEDs_SetAllLEDs>
  
  0000031a <EVENT_USB_Device_ConfigurationChanged>:
  /** Event handler for the library USB Configuration Changed event. */
  void EVENT_USB_Device_ConfigurationChanged(void)
  {
  	bool ConfigSuccess = true;
  
  	ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
   31a:	80 e0       	ldi	r24, 0x00	; 0
   31c:	91 e0       	ldi	r25, 0x01	; 1
   31e:	db d4       	rcall	.+2486   	; 0xcd6 <CDC_Device_ConfigureEndpoints>
  
  	LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
   320:	81 11       	cpse	r24, r1
   322:	02 c0       	rjmp	.+4      	; 0x328 <EVENT_USB_Device_ConfigurationChanged+0xe>
   324:	80 e2       	ldi	r24, 0x20	; 32
   326:	01 c0       	rjmp	.+2      	; 0x32a <EVENT_USB_Device_ConfigurationChanged+0x10>
   328:	80 e1       	ldi	r24, 0x10	; 16
   32a:	0f cf       	rjmp	.-482    	; 0x14a <LEDs_SetAllLEDs>
  
  0000032c <EVENT_USB_Device_ControlRequest>:
  }
  
  /** Event handler for the library USB Control Request reception event. */
  void EVENT_USB_Device_ControlRequest(void)
  {
  	CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
   32c:	80 e0       	ldi	r24, 0x00	; 0
   32e:	91 e0       	ldi	r25, 0x01	; 1
   330:	8c c5       	rjmp	.+2840   	; 0xe4a <CDC_Device_ProcessControlRequest>
  
  00000332 <__vector_23>:
  
  /** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
   *  for later transmission to the host.
   */
  ISR(USART1_RX_vect, ISR_BLOCK)
  {
   332:	1f 92       	push	r1
   334:	0f 92       	push	r0
   336:	0f b6       	in	r0, 0x3f	; 63
   338:	0f 92       	push	r0
   33a:	11 24       	eor	r1, r1
   33c:	2f 93       	push	r18
   33e:	3f 93       	push	r19
   340:	4f 93       	push	r20
   342:	5f 93       	push	r21
   344:	6f 93       	push	r22
   346:	7f 93       	push	r23
   348:	8f 93       	push	r24
   34a:	9f 93       	push	r25
   34c:	af 93       	push	r26
   34e:	bf 93       	push	r27
   350:	ef 93       	push	r30
   352:	ff 93       	push	r31
  	uint8_t ReceivedByte = UDR1;
   354:	60 91 ce 00 	lds	r22, 0x00CE
  
  	if ((USB_DeviceState == DEVICE_STATE_Configured) && !(RingBuffer_IsFull(&USARTtoUSB_Buffer)))
   358:	8e b3       	in	r24, 0x1e	; 30
   35a:	84 30       	cpi	r24, 0x04	; 4
   35c:	89 f4       	brne	.+34     	; 0x380 <__vector_23+0x4e>
  			static inline uint_reg_t GetGlobalInterruptMask(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				return SREG;
   35e:	8f b7       	in	r24, 0x3f	; 63
  			static inline void GlobalInterruptDisable(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				cli();
   360:	f8 94       	cli
   362:	20 91 a6 01 	lds	r18, 0x01A6
   366:	30 91 a7 01 	lds	r19, 0x01A7
  			static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				SREG = GlobalIntState;
   36a:	8f bf       	out	0x3f, r24	; 63
   36c:	80 91 a4 01 	lds	r24, 0x01A4
   370:	90 91 a5 01 	lds	r25, 0x01A5
   374:	28 17       	cp	r18, r24
   376:	39 07       	cpc	r19, r25
   378:	19 f0       	breq	.+6      	; 0x380 <__vector_23+0x4e>
  	  RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
   37a:	8c e9       	ldi	r24, 0x9C	; 156
   37c:	91 e0       	ldi	r25, 0x01	; 1
   37e:	eb de       	rcall	.-554    	; 0x156 <RingBuffer_Insert>
  }
   380:	ff 91       	pop	r31
   382:	ef 91       	pop	r30
   384:	bf 91       	pop	r27
   386:	af 91       	pop	r26
   388:	9f 91       	pop	r25
   38a:	8f 91       	pop	r24
   38c:	7f 91       	pop	r23
   38e:	6f 91       	pop	r22
   390:	5f 91       	pop	r21
   392:	4f 91       	pop	r20
   394:	3f 91       	pop	r19
   396:	2f 91       	pop	r18
   398:	0f 90       	pop	r0
   39a:	0f be       	out	0x3f, r0	; 63
   39c:	0f 90       	pop	r0
   39e:	1f 90       	pop	r1
   3a0:	18 95       	reti
  
  000003a2 <EVENT_CDC_Device_LineEncodingChanged>:
  /** Event handler for the CDC Class driver Line Encoding Changed event.
   *
   *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
   */
  void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
  {
   3a2:	cf 93       	push	r28
   3a4:	fc 01       	movw	r30, r24
  	uint8_t ConfigMask = 0;
  
  	switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
   3a6:	81 8d       	ldd	r24, Z+25	; 0x19
   3a8:	81 30       	cpi	r24, 0x01	; 1
   3aa:	21 f0       	breq	.+8      	; 0x3b4 <EVENT_CDC_Device_LineEncodingChanged+0x12>
   3ac:	82 30       	cpi	r24, 0x02	; 2
   3ae:	21 f4       	brne	.+8      	; 0x3b8 <EVENT_CDC_Device_LineEncodingChanged+0x16>
  	{
  		case CDC_PARITY_Odd:
  			ConfigMask = ((1 << UPM11) | (1 << UPM10));
  			break;
  		case CDC_PARITY_Even:
  			ConfigMask = (1 << UPM11);
   3b0:	c0 e2       	ldi	r28, 0x20	; 32
  			break;
   3b2:	03 c0       	rjmp	.+6      	; 0x3ba <EVENT_CDC_Device_LineEncodingChanged+0x18>
  	uint8_t ConfigMask = 0;
  
  	switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
  	{
  		case CDC_PARITY_Odd:
  			ConfigMask = ((1 << UPM11) | (1 << UPM10));
   3b4:	c0 e3       	ldi	r28, 0x30	; 48
   3b6:	01 c0       	rjmp	.+2      	; 0x3ba <EVENT_CDC_Device_LineEncodingChanged+0x18>
   *
   *  \param[in] CDCInterfaceInfo  Pointer to the CDC class interface configuration structure being referenced
   */
  void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
  {
  	uint8_t ConfigMask = 0;
   3b8:	c0 e0       	ldi	r28, 0x00	; 0
  		case CDC_PARITY_Even:
  			ConfigMask = (1 << UPM11);
  			break;
  	}
  
  	if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
   3ba:	80 8d       	ldd	r24, Z+24	; 0x18
   3bc:	82 30       	cpi	r24, 0x02	; 2
   3be:	09 f4       	brne	.+2      	; 0x3c2 <EVENT_CDC_Device_LineEncodingChanged+0x20>
  	  ConfigMask |= (1 << USBS1);
   3c0:	c8 60       	ori	r28, 0x08	; 8
  
  	switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
   3c2:	82 8d       	ldd	r24, Z+26	; 0x1a
   3c4:	87 30       	cpi	r24, 0x07	; 7
   3c6:	31 f0       	breq	.+12     	; 0x3d4 <EVENT_CDC_Device_LineEncodingChanged+0x32>
   3c8:	88 30       	cpi	r24, 0x08	; 8
   3ca:	31 f0       	breq	.+12     	; 0x3d8 <EVENT_CDC_Device_LineEncodingChanged+0x36>
   3cc:	86 30       	cpi	r24, 0x06	; 6
   3ce:	29 f4       	brne	.+10     	; 0x3da <EVENT_CDC_Device_LineEncodingChanged+0x38>
  	{
  		case 6:
  			ConfigMask |= (1 << UCSZ10);
   3d0:	c2 60       	ori	r28, 0x02	; 2
  			break;
   3d2:	03 c0       	rjmp	.+6      	; 0x3da <EVENT_CDC_Device_LineEncodingChanged+0x38>
  		case 7:
  			ConfigMask |= (1 << UCSZ11);
   3d4:	c4 60       	ori	r28, 0x04	; 4
  			break;
   3d6:	01 c0       	rjmp	.+2      	; 0x3da <EVENT_CDC_Device_LineEncodingChanged+0x38>
  		case 8:
  			ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
   3d8:	c6 60       	ori	r28, 0x06	; 6
  			break;
  	}
  
  	/* Keep the TX line held high (idle) while the USART is reconfigured */
  	PORTD |= (1 << 3);
   3da:	5b 9a       	sbi	0x0b, 3	; 11
  
  	/* Must turn off USART before reconfiguring it, otherwise incorrect operation may occur */
  	UCSR1B = 0;
   3dc:	10 92 c9 00 	sts	0x00C9, r1
  	UCSR1A = 0;
   3e0:	10 92 c8 00 	sts	0x00C8, r1
  	UCSR1C = 0;
   3e4:	10 92 ca 00 	sts	0x00CA, r1
  
  	/* Set the new baud rate before configuring the USART */
  	UBRR1  = SERIAL_2X_UBBRVAL(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
   3e8:	24 89       	ldd	r18, Z+20	; 0x14
   3ea:	35 89       	ldd	r19, Z+21	; 0x15
   3ec:	46 89       	ldd	r20, Z+22	; 0x16
   3ee:	57 89       	ldd	r21, Z+23	; 0x17
   3f0:	da 01       	movw	r26, r20
   3f2:	c9 01       	movw	r24, r18
   3f4:	b6 95       	lsr	r27
   3f6:	a7 95       	ror	r26
   3f8:	97 95       	ror	r25
   3fa:	87 95       	ror	r24
   3fc:	bc 01       	movw	r22, r24
   3fe:	cd 01       	movw	r24, r26
   400:	60 5c       	subi	r22, 0xC0	; 192
   402:	7d 4b       	sbci	r23, 0xBD	; 189
   404:	80 4f       	sbci	r24, 0xF0	; 240
   406:	9f 4f       	sbci	r25, 0xFF	; 255
   408:	cf d5       	rcall	.+2974   	; 0xfa8 <__udivmodsi4>
   40a:	21 50       	subi	r18, 0x01	; 1
   40c:	31 09       	sbc	r19, r1
   40e:	30 93 cd 00 	sts	0x00CD, r19
   412:	20 93 cc 00 	sts	0x00CC, r18
  
  	/* Reconfigure the USART in double speed mode for a wider baud rate range at the expense of accuracy */
  	UCSR1C = ConfigMask;
   416:	c0 93 ca 00 	sts	0x00CA, r28
  	UCSR1A = (1 << U2X1);
   41a:	82 e0       	ldi	r24, 0x02	; 2
   41c:	80 93 c8 00 	sts	0x00C8, r24
  	UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
   420:	88 e9       	ldi	r24, 0x98	; 152
   422:	80 93 c9 00 	sts	0x00C9, r24
  
  	/* Release the TX line after the USART has been reconfigured */
  	PORTD &= ~(1 << 3);
   426:	5b 98       	cbi	0x0b, 3	; 11
  }
   428:	cf 91       	pop	r28
   42a:	08 95       	ret
  
  0000042c <CALLBACK_USB_GetDescriptor>:
   */
  uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
                                      const uint16_t wIndex,
                                      const void** const DescriptorAddress)
  {
  	const uint8_t  DescriptorType   = (wValue >> 8);
   42c:	29 2f       	mov	r18, r25
   42e:	33 27       	eor	r19, r19
  	const uint8_t  DescriptorNumber = (wValue & 0xFF);
  
  	const void* Address = NULL;
  	uint16_t    Size    = NO_DESCRIPTOR;
  
  	switch (DescriptorType)
   430:	22 30       	cpi	r18, 0x02	; 2
   432:	31 05       	cpc	r19, r1
   434:	59 f0       	breq	.+22     	; 0x44c <CALLBACK_USB_GetDescriptor+0x20>
   436:	23 30       	cpi	r18, 0x03	; 3
   438:	31 05       	cpc	r19, r1
   43a:	69 f0       	breq	.+26     	; 0x456 <CALLBACK_USB_GetDescriptor+0x2a>
   43c:	21 30       	cpi	r18, 0x01	; 1
   43e:	31 05       	cpc	r19, r1
   440:	f9 f4       	brne	.+62     	; 0x480 <CALLBACK_USB_GetDescriptor+0x54>
  	{
  		case DTYPE_Device:
  			Address = &DeviceDescriptor;
  			Size    = sizeof(USB_Descriptor_Device_t);
   442:	82 e1       	ldi	r24, 0x12	; 18
   444:	90 e0       	ldi	r25, 0x00	; 0
  	uint16_t    Size    = NO_DESCRIPTOR;
  
  	switch (DescriptorType)
  	{
  		case DTYPE_Device:
  			Address = &DeviceDescriptor;
   446:	20 e0       	ldi	r18, 0x00	; 0
   448:	31 e0       	ldi	r19, 0x01	; 1
   44a:	1e c0       	rjmp	.+60     	; 0x488 <CALLBACK_USB_GetDescriptor+0x5c>
  			Size    = sizeof(USB_Descriptor_Device_t);
  			break;
  		case DTYPE_Configuration:
  			Address = &ConfigurationDescriptor;
  			Size    = sizeof(USB_Descriptor_Configuration_t);
   44c:	8e e3       	ldi	r24, 0x3E	; 62
   44e:	90 e0       	ldi	r25, 0x00	; 0
  		case DTYPE_Device:
  			Address = &DeviceDescriptor;
  			Size    = sizeof(USB_Descriptor_Device_t);
  			break;
  		case DTYPE_Configuration:
  			Address = &ConfigurationDescriptor;
   450:	22 ec       	ldi	r18, 0xC2	; 194
   452:	30 e0       	ldi	r19, 0x00	; 0
  			Size    = sizeof(USB_Descriptor_Configuration_t);
  			break;
   454:	19 c0       	rjmp	.+50     	; 0x488 <CALLBACK_USB_GetDescriptor+0x5c>
   456:	99 27       	eor	r25, r25
  		case DTYPE_String:
  			switch (DescriptorNumber)
   458:	81 30       	cpi	r24, 0x01	; 1
   45a:	91 05       	cpc	r25, r1
   45c:	41 f0       	breq	.+16     	; 0x46e <CALLBACK_USB_GetDescriptor+0x42>
   45e:	82 30       	cpi	r24, 0x02	; 2
   460:	91 05       	cpc	r25, r1
   462:	41 f0       	breq	.+16     	; 0x474 <CALLBACK_USB_GetDescriptor+0x48>
   464:	89 2b       	or	r24, r25
   466:	61 f4       	brne	.+24     	; 0x480 <CALLBACK_USB_GetDescriptor+0x54>
  			{
  				case STRING_ID_Language:
  					Address = &LanguageString;
  					Size    = pgm_read_byte(&LanguageString.Header.Size);
   468:	ee eb       	ldi	r30, 0xBE	; 190
   46a:	f0 e0       	ldi	r31, 0x00	; 0
   46c:	05 c0       	rjmp	.+10     	; 0x478 <CALLBACK_USB_GetDescriptor+0x4c>
  					break;
  				case STRING_ID_Manufacturer:
  					Address = &ManufacturerString;
  					Size    = pgm_read_byte(&ManufacturerString.Header.Size);
   46e:	e4 ea       	ldi	r30, 0xA4	; 164
   470:	f0 e0       	ldi	r31, 0x00	; 0
   472:	02 c0       	rjmp	.+4      	; 0x478 <CALLBACK_USB_GetDescriptor+0x4c>
  					break;
  				case STRING_ID_Product:
  					Address = &ProductString;
  					Size    = pgm_read_byte(&ProductString.Header.Size);
   474:	e4 e7       	ldi	r30, 0x74	; 116
   476:	f0 e0       	ldi	r31, 0x00	; 0
   478:	84 91       	lpm	r24, Z
   47a:	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;
   47c:	9f 01       	movw	r18, r30
  					Size    = pgm_read_byte(&ProductString.Header.Size);
  					break;
   47e:	04 c0       	rjmp	.+8      	; 0x488 <CALLBACK_USB_GetDescriptor+0x5c>
  {
  	const uint8_t  DescriptorType   = (wValue >> 8);
  	const uint8_t  DescriptorNumber = (wValue & 0xFF);
  
  	const void* Address = NULL;
  	uint16_t    Size    = NO_DESCRIPTOR;
   480:	80 e0       	ldi	r24, 0x00	; 0
   482:	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;
   484:	20 e0       	ldi	r18, 0x00	; 0
   486:	30 e0       	ldi	r19, 0x00	; 0
  			}
  
  			break;
  	}
  
  	*DescriptorAddress = Address;
   488:	fa 01       	movw	r30, r20
   48a:	31 83       	std	Z+1, r19	; 0x01
   48c:	20 83       	st	Z, r18
  	return Size;
  }
   48e:	08 95       	ret
  
  00000490 <Endpoint_Write_Control_Stream_LE>:
  		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
  		  return ENDPOINT_RWCSTREAM_BusSuspended;
  	}
  
  	return ENDPOINT_RWCSTREAM_NoError;
  }
   490:	20 91 3e 02 	lds	r18, 0x023E
   494:	30 91 3f 02 	lds	r19, 0x023F
   498:	26 17       	cp	r18, r22
   49a:	37 07       	cpc	r19, r23
   49c:	48 f0       	brcs	.+18     	; 0x4b0 <Endpoint_Write_Control_Stream_LE+0x20>
   49e:	61 15       	cp	r22, r1
   4a0:	71 05       	cpc	r23, r1
   4a2:	39 f4       	brne	.+14     	; 0x4b2 <Endpoint_Write_Control_Stream_LE+0x22>
   4a4:	20 91 e8 00 	lds	r18, 0x00E8
   4a8:	2e 77       	andi	r18, 0x7E	; 126
   4aa:	20 93 e8 00 	sts	0x00E8, r18
   4ae:	01 c0       	rjmp	.+2      	; 0x4b2 <Endpoint_Write_Control_Stream_LE+0x22>
   4b0:	b9 01       	movw	r22, r18
   4b2:	40 e0       	ldi	r20, 0x00	; 0
   4b4:	61 15       	cp	r22, r1
   4b6:	71 05       	cpc	r23, r1
   4b8:	79 f1       	breq	.+94     	; 0x518 <Endpoint_Write_Control_Stream_LE+0x88>
   4ba:	2e b3       	in	r18, 0x1e	; 30
   4bc:	22 23       	and	r18, r18
   4be:	f1 f1       	breq	.+124    	; 0x53c <Endpoint_Write_Control_Stream_LE+0xac>
   4c0:	25 30       	cpi	r18, 0x05	; 5
   4c2:	f1 f1       	breq	.+124    	; 0x540 <Endpoint_Write_Control_Stream_LE+0xb0>
   4c4:	20 91 e8 00 	lds	r18, 0x00E8
   4c8:	23 fd       	sbrc	r18, 3
   4ca:	3c c0       	rjmp	.+120    	; 0x544 <Endpoint_Write_Control_Stream_LE+0xb4>
   4cc:	20 91 e8 00 	lds	r18, 0x00E8
   4d0:	22 fd       	sbrc	r18, 2
   4d2:	2e c0       	rjmp	.+92     	; 0x530 <Endpoint_Write_Control_Stream_LE+0xa0>
   4d4:	20 91 e8 00 	lds	r18, 0x00E8
   4d8:	20 ff       	sbrs	r18, 0
   4da:	ec cf       	rjmp	.-40     	; 0x4b4 <Endpoint_Write_Control_Stream_LE+0x24>
   4dc:	20 91 f2 00 	lds	r18, 0x00F2
   4e0:	30 e0       	ldi	r19, 0x00	; 0
   4e2:	fc 01       	movw	r30, r24
   4e4:	cf 01       	movw	r24, r30
   4e6:	61 15       	cp	r22, r1
   4e8:	71 05       	cpc	r23, r1
   4ea:	59 f0       	breq	.+22     	; 0x502 <Endpoint_Write_Control_Stream_LE+0x72>
   4ec:	28 30       	cpi	r18, 0x08	; 8
   4ee:	31 05       	cpc	r19, r1
   4f0:	40 f4       	brcc	.+16     	; 0x502 <Endpoint_Write_Control_Stream_LE+0x72>
   4f2:	81 91       	ld	r24, Z+
   4f4:	80 93 f1 00 	sts	0x00F1, r24
   4f8:	61 50       	subi	r22, 0x01	; 1
   4fa:	71 09       	sbc	r23, r1
   4fc:	2f 5f       	subi	r18, 0xFF	; 255
   4fe:	3f 4f       	sbci	r19, 0xFF	; 255
   500:	f1 cf       	rjmp	.-30     	; 0x4e4 <Endpoint_Write_Control_Stream_LE+0x54>
   502:	41 e0       	ldi	r20, 0x01	; 1
   504:	28 30       	cpi	r18, 0x08	; 8
   506:	31 05       	cpc	r19, r1
   508:	09 f0       	breq	.+2      	; 0x50c <Endpoint_Write_Control_Stream_LE+0x7c>
   50a:	40 e0       	ldi	r20, 0x00	; 0
   50c:	20 91 e8 00 	lds	r18, 0x00E8
   510:	2e 77       	andi	r18, 0x7E	; 126
   512:	20 93 e8 00 	sts	0x00E8, r18
   516:	ce cf       	rjmp	.-100    	; 0x4b4 <Endpoint_Write_Control_Stream_LE+0x24>
   518:	41 11       	cpse	r20, r1
   51a:	cf cf       	rjmp	.-98     	; 0x4ba <Endpoint_Write_Control_Stream_LE+0x2a>
   51c:	09 c0       	rjmp	.+18     	; 0x530 <Endpoint_Write_Control_Stream_LE+0xa0>
   51e:	8e b3       	in	r24, 0x1e	; 30
   520:	88 23       	and	r24, r24
   522:	61 f0       	breq	.+24     	; 0x53c <Endpoint_Write_Control_Stream_LE+0xac>
   524:	85 30       	cpi	r24, 0x05	; 5
   526:	61 f0       	breq	.+24     	; 0x540 <Endpoint_Write_Control_Stream_LE+0xb0>
   528:	80 91 e8 00 	lds	r24, 0x00E8
   52c:	83 fd       	sbrc	r24, 3
   52e:	0a c0       	rjmp	.+20     	; 0x544 <Endpoint_Write_Control_Stream_LE+0xb4>
   530:	80 91 e8 00 	lds	r24, 0x00E8
   534:	82 ff       	sbrs	r24, 2
   536:	f3 cf       	rjmp	.-26     	; 0x51e <Endpoint_Write_Control_Stream_LE+0x8e>
   538:	80 e0       	ldi	r24, 0x00	; 0
   53a:	08 95       	ret
   53c:	82 e0       	ldi	r24, 0x02	; 2
   53e:	08 95       	ret
   540:	83 e0       	ldi	r24, 0x03	; 3
   542:	08 95       	ret
   544:	81 e0       	ldi	r24, 0x01	; 1
   546:	08 95       	ret
  
  00000548 <Endpoint_Write_Control_PStream_LE>:
                              uint16_t Length)
  {
  	uint8_t* DataStream     = ((uint8_t*)Buffer + TEMPLATE_BUFFER_OFFSET(Length));
  	bool     LastPacketFull = false;
  
  	if (Length > USB_ControlRequest.wLength)
   548:	20 91 3e 02 	lds	r18, 0x023E
   54c:	30 91 3f 02 	lds	r19, 0x023F
   550:	26 17       	cp	r18, r22
   552:	37 07       	cpc	r19, r23
   554:	48 f0       	brcs	.+18     	; 0x568 <Endpoint_Write_Control_PStream_LE+0x20>
  	  Length = USB_ControlRequest.wLength;
  	else if (!(Length))
   556:	61 15       	cp	r22, r1
   558:	71 05       	cpc	r23, r1
   55a:	39 f4       	brne	.+14     	; 0x56a <Endpoint_Write_Control_PStream_LE+0x22>
  			 */
  			static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
  			static inline void Endpoint_ClearIN(void)
  			{
  				#if !defined(CONTROL_ONLY_DEVICE)
  					UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
   55c:	20 91 e8 00 	lds	r18, 0x00E8
   560:	2e 77       	andi	r18, 0x7E	; 126
   562:	20 93 e8 00 	sts	0x00E8, r18
   566:	01 c0       	rjmp	.+2      	; 0x56a <Endpoint_Write_Control_PStream_LE+0x22>
   568:	b9 01       	movw	r22, r18
   56a:	fc 01       	movw	r30, r24
   56c:	20 e0       	ldi	r18, 0x00	; 0
  	  Endpoint_ClearIN();
  
  	while (Length || LastPacketFull)
   56e:	61 15       	cp	r22, r1
   570:	71 05       	cpc	r23, r1
   572:	61 f1       	breq	.+88     	; 0x5cc <Endpoint_Write_Control_PStream_LE+0x84>
  	{
  		uint8_t USB_DeviceState_LCL = USB_DeviceState;
   574:	8e b3       	in	r24, 0x1e	; 30
  
  		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
   576:	88 23       	and	r24, r24
   578:	d9 f1       	breq	.+118    	; 0x5f0 <Endpoint_Write_Control_PStream_LE+0xa8>
  		  return ENDPOINT_RWCSTREAM_DeviceDisconnected;
  		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
   57a:	85 30       	cpi	r24, 0x05	; 5
   57c:	d9 f1       	breq	.+118    	; 0x5f4 <Endpoint_Write_Control_PStream_LE+0xac>
  			 *  \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);
   57e:	80 91 e8 00 	lds	r24, 0x00E8
  		  return ENDPOINT_RWCSTREAM_BusSuspended;
  		else if (Endpoint_IsSETUPReceived())
   582:	83 fd       	sbrc	r24, 3
   584:	39 c0       	rjmp	.+114    	; 0x5f8 <Endpoint_Write_Control_PStream_LE+0xb0>
  			 *  \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);
   586:	80 91 e8 00 	lds	r24, 0x00E8
  		  return ENDPOINT_RWCSTREAM_HostAborted;
  		else if (Endpoint_IsOUTReceived())
   58a:	82 fd       	sbrc	r24, 2
   58c:	2b c0       	rjmp	.+86     	; 0x5e4 <Endpoint_Write_Control_PStream_LE+0x9c>
  			 *  \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);
   58e:	80 91 e8 00 	lds	r24, 0x00E8
  		  break;
  
  		if (Endpoint_IsINReady())
   592:	80 ff       	sbrs	r24, 0
   594:	ec cf       	rjmp	.-40     	; 0x56e <Endpoint_Write_Control_PStream_LE+0x26>
  				#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);
  				#elif defined(USB_SERIES_2_AVR)
  					return UEBCLX;
   596:	80 91 f2 00 	lds	r24, 0x00F2
   59a:	90 e0       	ldi	r25, 0x00	; 0
  		{
  			uint16_t BytesInEndpoint = Endpoint_BytesInEndpoint();
  
  			while (Length && (BytesInEndpoint < USB_Device_ControlEndpointSize))
   59c:	61 15       	cp	r22, r1
   59e:	71 05       	cpc	r23, r1
   5a0:	59 f0       	breq	.+22     	; 0x5b8 <Endpoint_Write_Control_PStream_LE+0x70>
   5a2:	88 30       	cpi	r24, 0x08	; 8
   5a4:	91 05       	cpc	r25, r1
   5a6:	40 f4       	brcc	.+16     	; 0x5b8 <Endpoint_Write_Control_PStream_LE+0x70>
  			{
  				TEMPLATE_TRANSFER_BYTE(DataStream);
   5a8:	24 91       	lpm	r18, Z
  			 *  \param[in] Data  Data to write into the the currently selected endpoint's FIFO buffer.
  			 */
  			static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
  			static inline void Endpoint_Write_8(const uint8_t Data)
  			{
  				UEDATX = Data;
   5aa:	20 93 f1 00 	sts	0x00F1, r18
  				TEMPLATE_BUFFER_MOVE(DataStream, 1);
   5ae:	31 96       	adiw	r30, 0x01	; 1
  				Length--;
   5b0:	61 50       	subi	r22, 0x01	; 1
   5b2:	71 09       	sbc	r23, r1
  				BytesInEndpoint++;
   5b4:	01 96       	adiw	r24, 0x01	; 1
   5b6:	f2 cf       	rjmp	.-28     	; 0x59c <Endpoint_Write_Control_PStream_LE+0x54>
  			}
  
  			LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
   5b8:	21 e0       	ldi	r18, 0x01	; 1
   5ba:	08 97       	sbiw	r24, 0x08	; 8
   5bc:	09 f0       	breq	.+2      	; 0x5c0 <Endpoint_Write_Control_PStream_LE+0x78>
   5be:	20 e0       	ldi	r18, 0x00	; 0
  			 */
  			static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
  			static inline void Endpoint_ClearIN(void)
  			{
  				#if !defined(CONTROL_ONLY_DEVICE)
  					UEINTX &= ~((1 << TXINI) | (1 << FIFOCON));
   5c0:	80 91 e8 00 	lds	r24, 0x00E8
   5c4:	8e 77       	andi	r24, 0x7E	; 126
   5c6:	80 93 e8 00 	sts	0x00E8, r24
   5ca:	d1 cf       	rjmp	.-94     	; 0x56e <Endpoint_Write_Control_PStream_LE+0x26>
  	if (Length > USB_ControlRequest.wLength)
  	  Length = USB_ControlRequest.wLength;
  	else if (!(Length))
  	  Endpoint_ClearIN();
  
  	while (Length || LastPacketFull)
   5cc:	21 11       	cpse	r18, r1
   5ce:	d2 cf       	rjmp	.-92     	; 0x574 <Endpoint_Write_Control_PStream_LE+0x2c>
   5d0:	09 c0       	rjmp	.+18     	; 0x5e4 <Endpoint_Write_Control_PStream_LE+0x9c>
  		}
  	}
  
  	while (!(Endpoint_IsOUTReceived()))
  	{
  		uint8_t USB_DeviceState_LCL = USB_DeviceState;
   5d2:	8e b3       	in	r24, 0x1e	; 30
  
  		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
   5d4:	88 23       	and	r24, r24
   5d6:	61 f0       	breq	.+24     	; 0x5f0 <Endpoint_Write_Control_PStream_LE+0xa8>
  		  return ENDPOINT_RWCSTREAM_DeviceDisconnected;
  		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
   5d8:	85 30       	cpi	r24, 0x05	; 5
   5da:	61 f0       	breq	.+24     	; 0x5f4 <Endpoint_Write_Control_PStream_LE+0xac>
  			 *  \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);
   5dc:	80 91 e8 00 	lds	r24, 0x00E8
  		  return ENDPOINT_RWCSTREAM_BusSuspended;
  		else if (Endpoint_IsSETUPReceived())
   5e0:	83 fd       	sbrc	r24, 3
   5e2:	0a c0       	rjmp	.+20     	; 0x5f8 <Endpoint_Write_Control_PStream_LE+0xb0>
  			 *  \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);
   5e4:	80 91 e8 00 	lds	r24, 0x00E8
  			LastPacketFull = (BytesInEndpoint == USB_Device_ControlEndpointSize);
  			Endpoint_ClearIN();
  		}
  	}
  
  	while (!(Endpoint_IsOUTReceived()))
   5e8:	82 ff       	sbrs	r24, 2
   5ea:	f3 cf       	rjmp	.-26     	; 0x5d2 <Endpoint_Write_Control_PStream_LE+0x8a>
  		  return ENDPOINT_RWCSTREAM_BusSuspended;
  		else if (Endpoint_IsSETUPReceived())
  		  return ENDPOINT_RWCSTREAM_HostAborted;
  	}
  
  	return ENDPOINT_RWCSTREAM_NoError;
   5ec:	80 e0       	ldi	r24, 0x00	; 0
   5ee:	08 95       	ret
  	while (Length || LastPacketFull)
  	{
  		uint8_t USB_DeviceState_LCL = USB_DeviceState;
  
  		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
  		  return ENDPOINT_RWCSTREAM_DeviceDisconnected;
   5f0:	82 e0       	ldi	r24, 0x02	; 2
   5f2:	08 95       	ret
  		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
  		  return ENDPOINT_RWCSTREAM_BusSuspended;
   5f4:	83 e0       	ldi	r24, 0x03	; 3
   5f6:	08 95       	ret
  		else if (Endpoint_IsSETUPReceived())
  		  return ENDPOINT_RWCSTREAM_HostAborted;
   5f8:	81 e0       	ldi	r24, 0x01	; 1
  		else if (Endpoint_IsSETUPReceived())
  		  return ENDPOINT_RWCSTREAM_HostAborted;
  	}
  
  	return ENDPOINT_RWCSTREAM_NoError;
  }
   5fa:	08 95       	ret
  
  000005fc <Endpoint_ConfigureEndpoint_Prv>:
  		UEIENX  = 0;
  		UEINTX  = 0;
  		UECFG1X = 0;
  		Endpoint_DisableEndpoint();
  	}
  }
   5fc:	98 2f       	mov	r25, r24
   5fe:	95 30       	cpi	r25, 0x05	; 5
   600:	58 f5       	brcc	.+86     	; 0x658 <Endpoint_ConfigureEndpoint_Prv+0x5c>
   602:	90 93 e9 00 	sts	0x00E9, r25
   606:	98 17       	cp	r25, r24
   608:	39 f0       	breq	.+14     	; 0x618 <Endpoint_ConfigureEndpoint_Prv+0x1c>
   60a:	70 91 ec 00 	lds	r23, 0x00EC
   60e:	20 91 ed 00 	lds	r18, 0x00ED
   612:	50 91 f0 00 	lds	r21, 0x00F0
   616:	03 c0       	rjmp	.+6      	; 0x61e <Endpoint_ConfigureEndpoint_Prv+0x22>
   618:	24 2f       	mov	r18, r20
   61a:	76 2f       	mov	r23, r22
   61c:	50 e0       	ldi	r21, 0x00	; 0
   61e:	21 ff       	sbrs	r18, 1
   620:	19 c0       	rjmp	.+50     	; 0x654 <Endpoint_ConfigureEndpoint_Prv+0x58>
   622:	30 91 eb 00 	lds	r19, 0x00EB
   626:	3e 7f       	andi	r19, 0xFE	; 254
   628:	30 93 eb 00 	sts	0x00EB, r19
   62c:	30 91 ed 00 	lds	r19, 0x00ED
   630:	3d 7f       	andi	r19, 0xFD	; 253
   632:	30 93 ed 00 	sts	0x00ED, r19
   636:	30 91 eb 00 	lds	r19, 0x00EB
   63a:	31 60       	ori	r19, 0x01	; 1
   63c:	30 93 eb 00 	sts	0x00EB, r19
   640:	70 93 ec 00 	sts	0x00EC, r23
   644:	20 93 ed 00 	sts	0x00ED, r18
   648:	50 93 f0 00 	sts	0x00F0, r21
   64c:	20 91 ee 00 	lds	r18, 0x00EE
   650:	27 ff       	sbrs	r18, 7
   652:	07 c0       	rjmp	.+14     	; 0x662 <Endpoint_ConfigureEndpoint_Prv+0x66>
   654:	9f 5f       	subi	r25, 0xFF	; 255
   656:	d3 cf       	rjmp	.-90     	; 0x5fe <Endpoint_ConfigureEndpoint_Prv+0x2>
   658:	8f 70       	andi	r24, 0x0F	; 15
   65a:	80 93 e9 00 	sts	0x00E9, r24
   65e:	81 e0       	ldi	r24, 0x01	; 1
   660:	08 95       	ret
   662:	80 e0       	ldi	r24, 0x00	; 0
   664:	08 95       	ret
  
  00000666 <Endpoint_ConfigureEndpointTable>:
   666:	ef 92       	push	r14
   668:	ff 92       	push	r15
   66a:	0f 93       	push	r16
   66c:	1f 93       	push	r17
   66e:	cf 93       	push	r28
   670:	df 93       	push	r29
   672:	e6 2e       	mov	r14, r22
   674:	ec 01       	movw	r28, r24
   676:	8c 01       	movw	r16, r24
   678:	0c 5f       	subi	r16, 0xFC	; 252
   67a:	1f 4f       	sbci	r17, 0xFF	; 255
   67c:	f1 2c       	mov	r15, r1
   67e:	fe 14       	cp	r15, r14
   680:	99 f1       	breq	.+102    	; 0x6e8 <Endpoint_ConfigureEndpointTable+0x82>
   682:	98 81       	ld	r25, Y
   684:	99 23       	and	r25, r25
   686:	59 f1       	breq	.+86     	; 0x6de <Endpoint_ConfigureEndpointTable+0x78>
   688:	f8 01       	movw	r30, r16
   68a:	20 81       	ld	r18, Z
   68c:	69 81       	ldd	r22, Y+1	; 0x01
   68e:	7a 81       	ldd	r23, Y+2	; 0x02
   690:	31 97       	sbiw	r30, 0x01	; 1
   692:	30 81       	ld	r19, Z
   694:	89 2f       	mov	r24, r25
   696:	8f 70       	andi	r24, 0x0F	; 15
   698:	85 30       	cpi	r24, 0x05	; 5
   69a:	10 f0       	brcs	.+4      	; 0x6a0 <Endpoint_ConfigureEndpointTable+0x3a>
   69c:	80 e0       	ldi	r24, 0x00	; 0
   69e:	25 c0       	rjmp	.+74     	; 0x6ea <Endpoint_ConfigureEndpointTable+0x84>
   6a0:	22 30       	cpi	r18, 0x02	; 2
   6a2:	10 f4       	brcc	.+4      	; 0x6a8 <Endpoint_ConfigureEndpointTable+0x42>
   6a4:	42 e0       	ldi	r20, 0x02	; 2
   6a6:	01 c0       	rjmp	.+2      	; 0x6aa <Endpoint_ConfigureEndpointTable+0x44>
   6a8:	46 e0       	ldi	r20, 0x06	; 6
   6aa:	e8 e0       	ldi	r30, 0x08	; 8
   6ac:	f0 e0       	ldi	r31, 0x00	; 0
   6ae:	20 e0       	ldi	r18, 0x00	; 0
   6b0:	e6 17       	cp	r30, r22
   6b2:	f7 07       	cpc	r31, r23
   6b4:	20 f4       	brcc	.+8      	; 0x6be <Endpoint_ConfigureEndpointTable+0x58>
   6b6:	2f 5f       	subi	r18, 0xFF	; 255
   6b8:	ee 0f       	add	r30, r30
   6ba:	ff 1f       	adc	r31, r31
   6bc:	f9 cf       	rjmp	.-14     	; 0x6b0 <Endpoint_ConfigureEndpointTable+0x4a>
   6be:	22 95       	swap	r18
   6c0:	20 7f       	andi	r18, 0xF0	; 240
   6c2:	42 2b       	or	r20, r18
   6c4:	23 2f       	mov	r18, r19
   6c6:	22 95       	swap	r18
   6c8:	22 0f       	add	r18, r18
   6ca:	22 0f       	add	r18, r18
   6cc:	20 7c       	andi	r18, 0xC0	; 192
   6ce:	99 1f       	adc	r25, r25
   6d0:	99 27       	eor	r25, r25
   6d2:	99 1f       	adc	r25, r25
   6d4:	62 2f       	mov	r22, r18
   6d6:	69 2b       	or	r22, r25
   6d8:	91 df       	rcall	.-222    	; 0x5fc <Endpoint_ConfigureEndpoint_Prv>
   6da:	88 23       	and	r24, r24
   6dc:	f9 f2       	breq	.-66     	; 0x69c <Endpoint_ConfigureEndpointTable+0x36>
   6de:	f3 94       	inc	r15
   6e0:	25 96       	adiw	r28, 0x05	; 5
   6e2:	0b 5f       	subi	r16, 0xFB	; 251
   6e4:	1f 4f       	sbci	r17, 0xFF	; 255
   6e6:	cb cf       	rjmp	.-106    	; 0x67e <Endpoint_ConfigureEndpointTable+0x18>
   6e8:	81 e0       	ldi	r24, 0x01	; 1
   6ea:	df 91       	pop	r29
   6ec:	cf 91       	pop	r28
   6ee:	1f 91       	pop	r17
   6f0:	0f 91       	pop	r16
   6f2:	ff 90       	pop	r15
   6f4:	ef 90       	pop	r14
   6f6:	08 95       	ret
  
  000006f8 <Endpoint_ClearStatusStage>:
  
  void Endpoint_ClearStatusStage(void)
  {
  	if (USB_ControlRequest.bmRequestType & REQDIR_DEVICETOHOST)
   6f8:	80 91 38 02 	lds	r24, 0x0238
   6fc:	87 ff       	sbrs	r24, 7
   6fe:	0f c0       	rjmp	.+30     	; 0x71e <Endpoint_ClearStatusStage+0x26>
  			 *  \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);
   700:	80 91 e8 00 	lds	r24, 0x00E8
  	{
  		while (!(Endpoint_IsOUTReceived()))
   704:	82 fd       	sbrc	r24, 2
   706:	04 c0       	rjmp	.+8      	; 0x710 <Endpoint_ClearStatusStage+0x18>
  		{
  			if (USB_DeviceState == DEVICE_STATE_Unattached)
   708:	8e b3       	in	r24, 0x1e	; 30
   70a:	81 11       	cpse	r24, r1
   70c:	f9 cf       	rjmp	.-14     	; 0x700 <Endpoint_ClearStatusStage+0x8>
   70e:	10 c0       	rjmp	.+32     	; 0x730 <Endpoint_ClearStatusStage+0x38>
  			 */
  			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));
   710:	80 91 e8 00 	lds	r24, 0x00E8
   714:	8b 77       	andi	r24, 0x7B	; 123
   716:	0a c0       	rjmp	.+20     	; 0x72c <Endpoint_ClearStatusStage+0x34>
  	}
  	else
  	{
  		while (!(Endpoint_IsINReady()))
  		{
  			if (USB_DeviceState == DEVICE_STATE_Unattached)
   718:	8e b3       	in	r24, 0x1e	; 30
   71a:	88 23       	and	r24, r24
   71c:	49 f0       	breq	.+18     	; 0x730 <Endpoint_ClearStatusStage+0x38>
  			 *  \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);
   71e:	80 91 e8 00 	lds	r24, 0x00E8
  
  		Endpoint_ClearOUT();
  	}
  	else
  	{
  		while (!(Endpoint_IsINReady()))
   722:	80 ff       	sbrs	r24, 0
   724:	f9 cf       	rjmp	.-14     	; 0x718 <Endpoint_ClearStatusStage+0x20>
  			 */
  			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));
   726:	80 91 e8 00 	lds	r24, 0x00E8
   72a:	8e 77       	andi	r24, 0x7E	; 126
   72c:	80 93 e8 00 	sts	0x00E8, r24
   730:	08 95       	ret
  
  00000732 <Endpoint_WaitUntilReady>:
  			 *  \return Current USB frame number from the USB controller.
  			 */
  			static inline uint16_t USB_Device_GetFrameNumber(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
  			static inline uint16_t USB_Device_GetFrameNumber(void)
  			{
  				return UDFNUM;
   732:	20 91 e4 00 	lds	r18, 0x00E4
   736:	30 91 e5 00 	lds	r19, 0x00E5
   73a:	95 e6       	ldi	r25, 0x65	; 101
  			 *  \return The currently selected endpoint's direction, as a \c ENDPOINT_DIR_* mask.
  			 */
  			static inline uint8_t Endpoint_GetEndpointDirection(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
  			static inline uint8_t Endpoint_GetEndpointDirection(void)
  			{
  				return (UECFG0X & (1 << EPDIR)) ? ENDPOINT_DIR_IN : ENDPOINT_DIR_OUT;
   73c:	40 91 ec 00 	lds	r20, 0x00EC
   740:	84 2f       	mov	r24, r20
   742:	81 70       	andi	r24, 0x01	; 1
   744:	40 ff       	sbrs	r20, 0
   746:	21 c0       	rjmp	.+66     	; 0x78a <Endpoint_WaitUntilReady+0x58>
  			 *  \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);
   748:	80 91 e8 00 	lds	r24, 0x00E8
  
  	for (;;)
  	{
  		if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
  		{
  			if (Endpoint_IsINReady())
   74c:	80 fd       	sbrc	r24, 0
   74e:	1b c0       	rjmp	.+54     	; 0x786 <Endpoint_WaitUntilReady+0x54>
  		{
  			if (Endpoint_IsOUTReceived())
  			  return ENDPOINT_READYWAIT_NoError;
  		}
  
  		uint8_t USB_DeviceState_LCL = USB_DeviceState;
   750:	8e b3       	in	r24, 0x1e	; 30
  
  		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
   752:	88 23       	and	r24, r24
   754:	91 f0       	breq	.+36     	; 0x77a <Endpoint_WaitUntilReady+0x48>
  		  return ENDPOINT_READYWAIT_DeviceDisconnected;
  		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
   756:	85 30       	cpi	r24, 0x05	; 5
   758:	91 f0       	breq	.+36     	; 0x77e <Endpoint_WaitUntilReady+0x4c>
  			 *  \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);
   75a:	80 91 eb 00 	lds	r24, 0x00EB
  		  return ENDPOINT_READYWAIT_BusSuspended;
  		else if (Endpoint_IsStalled())
   75e:	85 fd       	sbrc	r24, 5
   760:	10 c0       	rjmp	.+32     	; 0x782 <Endpoint_WaitUntilReady+0x50>
   762:	40 91 e4 00 	lds	r20, 0x00E4
   766:	50 91 e5 00 	lds	r21, 0x00E5
  		  return ENDPOINT_READYWAIT_EndpointStalled;
  
  		uint16_t CurrentFrameNumber = USB_Device_GetFrameNumber();
  
  		if (CurrentFrameNumber != PreviousFrameNumber)
   76a:	42 17       	cp	r20, r18
   76c:	53 07       	cpc	r21, r19
   76e:	31 f3       	breq	.-52     	; 0x73c <Endpoint_WaitUntilReady+0xa>
   770:	9a 01       	movw	r18, r20
   772:	91 50       	subi	r25, 0x01	; 1
  		{
  			PreviousFrameNumber = CurrentFrameNumber;
  
  			if (!(TimeoutMSRem--))
   774:	19 f7       	brne	.-58     	; 0x73c <Endpoint_WaitUntilReady+0xa>
  			  return ENDPOINT_READYWAIT_Timeout;
   776:	84 e0       	ldi	r24, 0x04	; 4
   778:	08 95       	ret
  		}
  
  		uint8_t USB_DeviceState_LCL = USB_DeviceState;
  
  		if (USB_DeviceState_LCL == DEVICE_STATE_Unattached)
  		  return ENDPOINT_READYWAIT_DeviceDisconnected;
   77a:	82 e0       	ldi	r24, 0x02	; 2
   77c:	08 95       	ret
  		else if (USB_DeviceState_LCL == DEVICE_STATE_Suspended)
  		  return ENDPOINT_READYWAIT_BusSuspended;
   77e:	83 e0       	ldi	r24, 0x03	; 3
   780:	08 95       	ret
  		else if (Endpoint_IsStalled())
  		  return ENDPOINT_READYWAIT_EndpointStalled;
   782:	81 e0       	ldi	r24, 0x01	; 1
   784:	08 95       	ret
  	for (;;)
  	{
  		if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
  		{
  			if (Endpoint_IsINReady())
  			  return ENDPOINT_READYWAIT_NoError;
   786:	80 e0       	ldi	r24, 0x00	; 0
   788:	08 95       	ret
  			 *  \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
  			 */
  			static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
  			static inline bool Endpoint_IsOUTReceived(void)
  			{
  				return ((UEINTX & (1 << RXOUTI)) ? true : false);
   78a:	40 91 e8 00 	lds	r20, 0x00E8
  		}
  		else
  		{
  			if (Endpoint_IsOUTReceived())
   78e:	42 ff       	sbrs	r20, 2
   790:	df cf       	rjmp	.-66     	; 0x750 <Endpoint_WaitUntilReady+0x1e>
  
  			if (!(TimeoutMSRem--))
  			  return ENDPOINT_READYWAIT_Timeout;
  		}
  	}
  }
   792:	08 95       	ret
  
  00000794 <USB_ResetInterface>:
  {
  	#if defined(USB_CAN_BE_BOTH)
  	bool UIDModeSelectEnabled = ((UHWCON & (1 << UIDE)) != 0);
  	#endif
  
  	USB_INT_DisableAllInterrupts();
   794:	3f d0       	rcall	.+126    	; 0x814 <USB_INT_DisableAllInterrupts>
  	USB_INT_ClearAllInterrupts();
   796:	41 d0       	rcall	.+130    	; 0x81a <USB_INT_ClearAllInterrupts>
  			}
  
  			static inline void USB_Controller_Reset(void) ATTR_ALWAYS_INLINE;
  			static inline void USB_Controller_Reset(void)
  			{
  				USBCON &= ~(1 << USBE);
   798:	80 91 d8 00 	lds	r24, 0x00D8
   79c:	8f 77       	andi	r24, 0x7F	; 127
   79e:	80 93 d8 00 	sts	0x00D8, r24
  				USBCON |=  (1 << USBE);
   7a2:	80 91 d8 00 	lds	r24, 0x00D8
   7a6:	80 68       	ori	r24, 0x80	; 128
   7a8:	80 93 d8 00 	sts	0x00D8, r24
  			}
  
  			static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE;
  			static inline void USB_CLK_Unfreeze(void)
  			{
  				USBCON &= ~(1 << FRZCLK);
   7ac:	80 91 d8 00 	lds	r24, 0x00D8
   7b0:	8f 7d       	andi	r24, 0xDF	; 223
   7b2:	80 93 d8 00 	sts	0x00D8, r24
  
  		/* Inline Functions: */
  			static inline void USB_PLL_On(void) ATTR_ALWAYS_INLINE;
  			static inline void USB_PLL_On(void)
  			{
  				PLLCSR = USB_PLL_PSC;
   7b6:	19 bc       	out	0x29, r1	; 41
  				PLLCSR = (USB_PLL_PSC | (1 << PLLE));
   7b8:	82 e0       	ldi	r24, 0x02	; 2
   7ba:	89 bd       	out	0x29, r24	; 41
  
  		if (!(USB_Options & USB_OPT_MANUAL_PLL))
  		{
  			#if defined(USB_SERIES_2_AVR)
  			USB_PLL_On();
  			while (!(USB_PLL_IsReady()));
   7bc:	09 b4       	in	r0, 0x29	; 41
   7be:	00 fe       	sbrs	r0, 0
   7c0:	fd cf       	rjmp	.-6      	; 0x7bc <USB_ResetInterface+0x28>
  }
  
  #if defined(USB_CAN_BE_DEVICE)
  static void USB_Init_Device(void)
  {
  	USB_DeviceState                 = DEVICE_STATE_Unattached;
   7c2:	1e ba       	out	0x1e, r1	; 30
  	USB_Device_ConfigurationNumber  = 0;
   7c4:	10 92 34 02 	sts	0x0234, r1
  
  	#if !defined(NO_DEVICE_REMOTE_WAKEUP)
  	USB_Device_RemoteWakeupEnabled  = false;
   7c8:	10 92 36 02 	sts	0x0236, r1
  	#endif
  
  	#if !defined(NO_DEVICE_SELF_POWER)
  	USB_Device_CurrentlySelfPowered = false;
   7cc:	10 92 35 02 	sts	0x0235, r1
  				uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);
  
  				if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
  				  return false;
  
  				return Endpoint_ConfigureEndpoint_Prv(Number,
   7d0:	42 e0       	ldi	r20, 0x02	; 2
   7d2:	60 e0       	ldi	r22, 0x00	; 0
   7d4:	80 e0       	ldi	r24, 0x00	; 0
   7d6:	12 df       	rcall	.-476    	; 0x5fc <Endpoint_ConfigureEndpoint_Prv>
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						UDINT  &= ~(1 << WAKEUPI);
  						break;
  					case USB_INT_SUSPI:
  						UDINT  &= ~(1 << SUSPI);
   7d8:	80 91 e1 00 	lds	r24, 0x00E1
   7dc:	8e 7f       	andi	r24, 0xFE	; 254
   7de:	80 93 e1 00 	sts	0x00E1, r24
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						UDIEN  |= (1 << WAKEUPE);
  						break;
  					case USB_INT_SUSPI:
  						UDIEN  |= (1 << SUSPE);
   7e2:	80 91 e2 00 	lds	r24, 0x00E2
   7e6:	81 60       	ori	r24, 0x01	; 1
   7e8:	80 93 e2 00 	sts	0x00E2, r24
  						break;
  					case USB_INT_EORSTI:
  						UDIEN  |= (1 << EORSTE);
   7ec:	80 91 e2 00 	lds	r24, 0x00E2
   7f0:	88 60       	ori	r24, 0x08	; 8
   7f2:	80 93 e2 00 	sts	0x00E2, 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);
   7f6:	80 91 e0 00 	lds	r24, 0x00E0
   7fa:	8e 7f       	andi	r24, 0xFE	; 254
   7fc:	80 93 e0 00 	sts	0x00E0, r24
   800:	08 95       	ret
  
  00000802 <USB_Init>:
  			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);
  			#else
  				REGCR  &= ~(1 << REGDIS);
   802:	e3 e6       	ldi	r30, 0x63	; 99
   804:	f0 e0       	ldi	r31, 0x00	; 0
   806:	80 81       	ld	r24, Z
   808:	8e 7f       	andi	r24, 0xFE	; 254
   80a:	80 83       	st	Z, r24
  		UHWCON &= ~(1 << UIDE);
  		USB_CurrentMode = Mode;
  	}
  	#endif
  
  	USB_IsInitialized = true;
   80c:	81 e0       	ldi	r24, 0x01	; 1
   80e:	80 93 37 02 	sts	0x0237, r24
  
  	USB_ResetInterface();
   812:	c0 cf       	rjmp	.-128    	; 0x794 <USB_ResetInterface>
  
  00000814 <USB_INT_DisableAllInterrupts>:
  	#if defined(USB_CAN_BE_HOST)
  	UHIEN   = 0;
  	#endif
  
  	#if defined(USB_CAN_BE_DEVICE)
  	UDIEN   = 0;
   814:	10 92 e2 00 	sts	0x00E2, r1
   818:	08 95       	ret
  
  0000081a <USB_INT_ClearAllInterrupts>:
  	#if defined(USB_CAN_BE_HOST)
  	UHINT  = 0;
  	#endif
  
  	#if defined(USB_CAN_BE_DEVICE)
  	UDINT  = 0;
   81a:	10 92 e1 00 	sts	0x00E1, r1
   81e:	08 95       	ret
  
  00000820 <__vector_11>:
  	#endif
  }
  
  ISR(USB_GEN_vect, ISR_BLOCK)
  {
   820:	1f 92       	push	r1
   822:	0f 92       	push	r0
   824:	0f b6       	in	r0, 0x3f	; 63
   826:	0f 92       	push	r0
   828:	11 24       	eor	r1, r1
   82a:	2f 93       	push	r18
   82c:	3f 93       	push	r19
   82e:	4f 93       	push	r20
   830:	5f 93       	push	r21
   832:	6f 93       	push	r22
   834:	7f 93       	push	r23
   836:	8f 93       	push	r24
   838:	9f 93       	push	r25
   83a:	af 93       	push	r26
   83c:	bf 93       	push	r27
   83e:	ef 93       	push	r30
   840:	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));
   842:	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))
   846:	82 ff       	sbrs	r24, 2
   848:	0a c0       	rjmp	.+20     	; 0x85e <__vector_11+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));
   84a:	80 91 e2 00 	lds	r24, 0x00E2
   84e:	82 ff       	sbrs	r24, 2
   850:	06 c0       	rjmp	.+12     	; 0x85e <__vector_11+0x3e>
  						break;
  					case USB_INT_EORSTI:
  						UDINT  &= ~(1 << EORSTI);
  						break;
  					case USB_INT_SOFI:
  						UDINT  &= ~(1 << SOFI);
   852:	80 91 e1 00 	lds	r24, 0x00E1
   856:	8b 7f       	andi	r24, 0xFB	; 251
   858:	80 93 e1 00 	sts	0x00E1, r24
  	{
  		USB_INT_Clear(USB_INT_SOFI);
  
  		EVENT_USB_Device_StartOfFrame();
   85c:	22 d2       	rcall	.+1092   	; 0xca2 <USB_Event_Stub>
  					#endif
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						return (UDINT  & (1 << WAKEUPI));
  					case USB_INT_SUSPI:
  						return (UDINT  & (1 << SUSPI));
   85e:	80 91 e1 00 	lds	r24, 0x00E1
  			EVENT_USB_Device_Disconnect();
  		}
  	}
  	#endif
  
  	if (USB_INT_HasOccurred(USB_INT_SUSPI) && USB_INT_IsEnabled(USB_INT_SUSPI))
   862:	80 ff       	sbrs	r24, 0
   864:	16 c0       	rjmp	.+44     	; 0x892 <__vector_11+0x72>
  					#endif
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						return (UDIEN  & (1 << WAKEUPE));
  					case USB_INT_SUSPI:
  						return (UDIEN  & (1 << SUSPE));
   866:	80 91 e2 00 	lds	r24, 0x00E2
   86a:	80 ff       	sbrs	r24, 0
   86c:	12 c0       	rjmp	.+36     	; 0x892 <__vector_11+0x72>
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						UDIEN  &= ~(1 << WAKEUPE);
  						break;
  					case USB_INT_SUSPI:
  						UDIEN  &= ~(1 << SUSPE);
   86e:	80 91 e2 00 	lds	r24, 0x00E2
   872:	8e 7f       	andi	r24, 0xFE	; 254
   874:	80 93 e2 00 	sts	0x00E2, r24
  						USBCON |= (1 << IDTE);
  						break;
  					#endif
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						UDIEN  |= (1 << WAKEUPE);
   878:	80 91 e2 00 	lds	r24, 0x00E2
   87c:	80 61       	ori	r24, 0x10	; 16
   87e:	80 93 e2 00 	sts	0x00E2, r24
  			#endif
  
  			static inline void USB_CLK_Freeze(void) ATTR_ALWAYS_INLINE;
  			static inline void USB_CLK_Freeze(void)
  			{
  				USBCON |=  (1 << FRZCLK);
   882:	80 91 d8 00 	lds	r24, 0x00D8
   886:	80 62       	ori	r24, 0x20	; 32
   888:	80 93 d8 00 	sts	0x00D8, r24
  			}
  
  			static inline void USB_PLL_Off(void) ATTR_ALWAYS_INLINE;
  			static inline void USB_PLL_Off(void)
  			{
  				PLLCSR = 0;
   88c:	19 bc       	out	0x29, r1	; 41
  
  		if (!(USB_Options & USB_OPT_MANUAL_PLL))
  		  USB_PLL_Off();
  
  		#if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
  		USB_DeviceState = DEVICE_STATE_Unattached;
   88e:	1e ba       	out	0x1e, r1	; 30
  		EVENT_USB_Device_Disconnect();
   890:	42 dd       	rcall	.-1404   	; 0x316 <EVENT_USB_Device_Disconnect>
  					case USB_INT_IDTI:
  						return (USBINT & (1 << IDTI));
  					#endif
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						return (UDINT  & (1 << WAKEUPI));
   892:	80 91 e1 00 	lds	r24, 0x00E1
  		USB_DeviceState = DEVICE_STATE_Suspended;
  		EVENT_USB_Device_Suspend();
  		#endif
  	}
  
  	if (USB_INT_HasOccurred(USB_INT_WAKEUPI) && USB_INT_IsEnabled(USB_INT_WAKEUPI))
   896:	84 ff       	sbrs	r24, 4
   898:	2d c0       	rjmp	.+90     	; 0x8f4 <__vector_11+0xd4>
  					case USB_INT_IDTI:
  						return (USBCON & (1 << IDTE));
  					#endif
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						return (UDIEN  & (1 << WAKEUPE));
   89a:	80 91 e2 00 	lds	r24, 0x00E2
   89e:	84 ff       	sbrs	r24, 4
   8a0:	29 c0       	rjmp	.+82     	; 0x8f4 <__vector_11+0xd4>
  
  		/* Inline Functions: */
  			static inline void USB_PLL_On(void) ATTR_ALWAYS_INLINE;
  			static inline void USB_PLL_On(void)
  			{
  				PLLCSR = USB_PLL_PSC;
   8a2:	19 bc       	out	0x29, r1	; 41
  				PLLCSR = (USB_PLL_PSC | (1 << PLLE));
   8a4:	82 e0       	ldi	r24, 0x02	; 2
   8a6:	89 bd       	out	0x29, r24	; 41
  	{
  		if (!(USB_Options & USB_OPT_MANUAL_PLL))
  		{
  			USB_PLL_On();
  			while (!(USB_PLL_IsReady()));
   8a8:	09 b4       	in	r0, 0x29	; 41
   8aa:	00 fe       	sbrs	r0, 0
   8ac:	fd cf       	rjmp	.-6      	; 0x8a8 <__vector_11+0x88>
  			}
  
  			static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE;
  			static inline void USB_CLK_Unfreeze(void)
  			{
  				USBCON &= ~(1 << FRZCLK);
   8ae:	80 91 d8 00 	lds	r24, 0x00D8
   8b2:	8f 7d       	andi	r24, 0xDF	; 223
   8b4:	80 93 d8 00 	sts	0x00D8, r24
  						USBINT &= ~(1 << IDTI);
  						break;
  					#endif
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						UDINT  &= ~(1 << WAKEUPI);
   8b8:	80 91 e1 00 	lds	r24, 0x00E1
   8bc:	8f 7e       	andi	r24, 0xEF	; 239
   8be:	80 93 e1 00 	sts	0x00E1, r24
  						USBCON &= ~(1 << IDTE);
  						break;
  					#endif
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						UDIEN  &= ~(1 << WAKEUPE);
   8c2:	80 91 e2 00 	lds	r24, 0x00E2
   8c6:	8f 7e       	andi	r24, 0xEF	; 239
   8c8:	80 93 e2 00 	sts	0x00E2, r24
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						UDIEN  |= (1 << WAKEUPE);
  						break;
  					case USB_INT_SUSPI:
  						UDIEN  |= (1 << SUSPE);
   8cc:	80 91 e2 00 	lds	r24, 0x00E2
   8d0:	81 60       	ori	r24, 0x01	; 1
   8d2:	80 93 e2 00 	sts	0x00E2, r24
  		USB_INT_Clear(USB_INT_WAKEUPI);
  
  		USB_INT_Disable(USB_INT_WAKEUPI);
  		USB_INT_Enable(USB_INT_SUSPI);
  
  		if (USB_Device_ConfigurationNumber)
   8d6:	80 91 34 02 	lds	r24, 0x0234
   8da:	88 23       	and	r24, r24
   8dc:	11 f0       	breq	.+4      	; 0x8e2 <__vector_11+0xc2>
  		  USB_DeviceState = DEVICE_STATE_Configured;
   8de:	84 e0       	ldi	r24, 0x04	; 4
   8e0:	07 c0       	rjmp	.+14     	; 0x8f0 <__vector_11+0xd0>
  			}
  
  			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));
   8e2:	80 91 e3 00 	lds	r24, 0x00E3
  		else
  		  USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Addressed : DEVICE_STATE_Powered;
   8e6:	87 fd       	sbrc	r24, 7
   8e8:	02 c0       	rjmp	.+4      	; 0x8ee <__vector_11+0xce>
   8ea:	81 e0       	ldi	r24, 0x01	; 1
   8ec:	01 c0       	rjmp	.+2      	; 0x8f0 <__vector_11+0xd0>
   8ee:	83 e0       	ldi	r24, 0x03	; 3
   8f0:	8e bb       	out	0x1e, r24	; 30
  
  		#if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
  		EVENT_USB_Device_Connect();
   8f2:	0f dd       	rcall	.-1506   	; 0x312 <EVENT_USB_Device_Connect>
  					case USB_INT_WAKEUPI:
  						return (UDINT  & (1 << WAKEUPI));
  					case USB_INT_SUSPI:
  						return (UDINT  & (1 << SUSPI));
  					case USB_INT_EORSTI:
  						return (UDINT  & (1 << EORSTI));
   8f4:	80 91 e1 00 	lds	r24, 0x00E1
  		#else
  		EVENT_USB_Device_WakeUp();
  		#endif
  	}
  
  	if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI))
   8f8:	83 ff       	sbrs	r24, 3
   8fa:	26 c0       	rjmp	.+76     	; 0x948 <__vector_11+0x128>
  					case USB_INT_WAKEUPI:
  						return (UDIEN  & (1 << WAKEUPE));
  					case USB_INT_SUSPI:
  						return (UDIEN  & (1 << SUSPE));
  					case USB_INT_EORSTI:
  						return (UDIEN  & (1 << EORSTE));
   8fc:	80 91 e2 00 	lds	r24, 0x00E2
   900:	83 ff       	sbrs	r24, 3
   902:	22 c0       	rjmp	.+68     	; 0x948 <__vector_11+0x128>
  						break;
  					case USB_INT_SUSPI:
  						UDINT  &= ~(1 << SUSPI);
  						break;
  					case USB_INT_EORSTI:
  						UDINT  &= ~(1 << EORSTI);
   904:	80 91 e1 00 	lds	r24, 0x00E1
   908:	87 7f       	andi	r24, 0xF7	; 247
   90a:	80 93 e1 00 	sts	0x00E1, r24
  	{
  		USB_INT_Clear(USB_INT_EORSTI);
  
  		USB_DeviceState                = DEVICE_STATE_Default;
   90e:	82 e0       	ldi	r24, 0x02	; 2
   910:	8e bb       	out	0x1e, r24	; 30
  		USB_Device_ConfigurationNumber = 0;
   912:	10 92 34 02 	sts	0x0234, r1
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						UDINT  &= ~(1 << WAKEUPI);
  						break;
  					case USB_INT_SUSPI:
  						UDINT  &= ~(1 << SUSPI);
   916:	80 91 e1 00 	lds	r24, 0x00E1
   91a:	8e 7f       	andi	r24, 0xFE	; 254
   91c:	80 93 e1 00 	sts	0x00E1, r24
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						UDIEN  &= ~(1 << WAKEUPE);
  						break;
  					case USB_INT_SUSPI:
  						UDIEN  &= ~(1 << SUSPE);
   920:	80 91 e2 00 	lds	r24, 0x00E2
   924:	8e 7f       	andi	r24, 0xFE	; 254
   926:	80 93 e2 00 	sts	0x00E2, r24
  						USBCON |= (1 << IDTE);
  						break;
  					#endif
  					#if defined(USB_CAN_BE_DEVICE)
  					case USB_INT_WAKEUPI:
  						UDIEN  |= (1 << WAKEUPE);
   92a:	80 91 e2 00 	lds	r24, 0x00E2
   92e:	80 61       	ori	r24, 0x10	; 16
   930:	80 93 e2 00 	sts	0x00E2, r24
  				uint8_t Number = (Address & ENDPOINT_EPNUM_MASK);
  
  				if (Number >= ENDPOINT_TOTAL_ENDPOINTS)
  				  return false;
  
  				return Endpoint_ConfigureEndpoint_Prv(Number,
   934:	42 e0       	ldi	r20, 0x02	; 2
   936:	60 e0       	ldi	r22, 0x00	; 0
   938:	80 e0       	ldi	r24, 0x00	; 0
   93a:	60 de       	rcall	.-832    	; 0x5fc <Endpoint_ConfigureEndpoint_Prv>
  						break;
  					case USB_INT_SOFI:
  						UDIEN  |= (1 << SOFE);
  						break;
  					case USB_INT_RXSTPI:
  						UEIENX |= (1 << RXSTPE);
   93c:	80 91 f0 00 	lds	r24, 0x00F0
   940:	88 60       	ori	r24, 0x08	; 8
   942:	80 93 f0 00 	sts	0x00F0, r24
  
  		#if defined(INTERRUPT_CONTROL_ENDPOINT)
  		USB_INT_Enable(USB_INT_RXSTPI);
  		#endif
  
  		EVENT_USB_Device_Reset();
   946:	ad d1       	rcall	.+858    	; 0xca2 <USB_Event_Stub>
  		USB_ResetInterface();
  
  		EVENT_USB_UIDChange();
  	}
  	#endif
  }
   948:	ff 91       	pop	r31
   94a:	ef 91       	pop	r30
   94c:	bf 91       	pop	r27
   94e:	af 91       	pop	r26
   950:	9f 91       	pop	r25
   952:	8f 91       	pop	r24
   954:	7f 91       	pop	r23
   956:	6f 91       	pop	r22
   958:	5f 91       	pop	r21
   95a:	4f 91       	pop	r20
   95c:	3f 91       	pop	r19
   95e:	2f 91       	pop	r18
   960:	0f 90       	pop	r0
   962:	0f be       	out	0x3f, r0	; 63
   964:	0f 90       	pop	r0
   966:	1f 90       	pop	r1
   968:	18 95       	reti
  
  0000096a <__vector_12>:
  
  #if defined(INTERRUPT_CONTROL_ENDPOINT) && defined(USB_CAN_BE_DEVICE)
  ISR(USB_COM_vect, ISR_BLOCK)
  {
   96a:	1f 92       	push	r1
   96c:	0f 92       	push	r0
   96e:	0f b6       	in	r0, 0x3f	; 63
   970:	0f 92       	push	r0
   972:	11 24       	eor	r1, r1
   974:	2f 93       	push	r18
   976:	3f 93       	push	r19
   978:	4f 93       	push	r20
   97a:	5f 93       	push	r21
   97c:	6f 93       	push	r22
   97e:	7f 93       	push	r23
   980:	8f 93       	push	r24
   982:	9f 93       	push	r25
   984:	af 93       	push	r26
   986:	bf 93       	push	r27
   988:	cf 93       	push	r28
   98a:	df 93       	push	r29
   98c:	ef 93       	push	r30
   98e:	ff 93       	push	r31
  			 */
  			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());
   990:	c0 91 e9 00 	lds	r28, 0x00E9
   994:	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;
   996:	80 91 ec 00 	lds	r24, 0x00EC
   99a:	d8 2f       	mov	r29, r24
   99c:	d1 70       	andi	r29, 0x01	; 1
   99e:	80 fd       	sbrc	r24, 0
   9a0:	d0 e8       	ldi	r29, 0x80	; 128
  			 */
  			static inline void Endpoint_SelectEndpoint(const uint8_t Address) ATTR_ALWAYS_INLINE;
  			static inline void Endpoint_SelectEndpoint(const uint8_t Address)
  			{
  				#if !defined(CONTROL_ONLY_DEVICE)
  					UENUM = (Address & ENDPOINT_EPNUM_MASK);
   9a2:	10 92 e9 00 	sts	0x00E9, r1
  						break;
  					case USB_INT_SOFI:
  						UDIEN  &= ~(1 << SOFE);
  						break;
  					case USB_INT_RXSTPI:
  						UEIENX &= ~(1 << RXSTPE);
   9a6:	80 91 f0 00 	lds	r24, 0x00F0
   9aa:	87 7f       	andi	r24, 0xF7	; 247
   9ac:	80 93 f0 00 	sts	0x00F0, r24
  			static inline void GlobalInterruptEnable(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				sei();
   9b0:	78 94       	sei
  	Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
  	USB_INT_Disable(USB_INT_RXSTPI);
  
  	GlobalInterruptEnable();
  
  	USB_Device_ProcessControlRequest();
   9b2:	1e d0       	rcall	.+60     	; 0x9f0 <USB_Device_ProcessControlRequest>
   9b4:	10 92 e9 00 	sts	0x00E9, r1
  						break;
  					case USB_INT_SOFI:
  						UDIEN  |= (1 << SOFE);
  						break;
  					case USB_INT_RXSTPI:
  						UEIENX |= (1 << RXSTPE);
   9b8:	80 91 f0 00 	lds	r24, 0x00F0
   9bc:	88 60       	ori	r24, 0x08	; 8
   9be:	80 93 f0 00 	sts	0x00F0, r24
  			 */
  			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());
   9c2:	cd 2b       	or	r28, r29
  			 */
  			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);
   9c4:	cf 70       	andi	r28, 0x0F	; 15
   9c6:	c0 93 e9 00 	sts	0x00E9, r28
  
  	Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
  	USB_INT_Enable(USB_INT_RXSTPI);
  	Endpoint_SelectEndpoint(PrevSelectedEndpoint);
  }
   9ca:	ff 91       	pop	r31
   9cc:	ef 91       	pop	r30
   9ce:	df 91       	pop	r29
   9d0:	cf 91       	pop	r28
   9d2:	bf 91       	pop	r27
   9d4:	af 91       	pop	r26
   9d6:	9f 91       	pop	r25
   9d8:	8f 91       	pop	r24
   9da:	7f 91       	pop	r23
   9dc:	6f 91       	pop	r22
   9de:	5f 91       	pop	r21
   9e0:	4f 91       	pop	r20
   9e2:	3f 91       	pop	r19
   9e4:	2f 91       	pop	r18
   9e6:	0f 90       	pop	r0
   9e8:	0f be       	out	0x3f, r0	; 63
   9ea:	0f 90       	pop	r0
   9ec:	1f 90       	pop	r1
   9ee:	18 95       	reti
  
  000009f0 <USB_Device_ProcessControlRequest>:
  #if !defined(NO_DEVICE_REMOTE_WAKEUP)
  bool    USB_Device_RemoteWakeupEnabled;
  #endif
  
  void USB_Device_ProcessControlRequest(void)
  {
   9f0:	1f 93       	push	r17
   9f2:	cf 93       	push	r28
   9f4:	df 93       	push	r29
   9f6:	cd b7       	in	r28, 0x3d	; 61
   9f8:	de b7       	in	r29, 0x3e	; 62
   9fa:	aa 97       	sbiw	r28, 0x2a	; 42
   9fc:	0f b6       	in	r0, 0x3f	; 63
   9fe:	f8 94       	cli
   a00:	de bf       	out	0x3e, r29	; 62
   a02:	0f be       	out	0x3f, r0	; 63
   a04:	cd bf       	out	0x3d, r28	; 61
   a06:	e8 e3       	ldi	r30, 0x38	; 56
   a08:	f2 e0       	ldi	r31, 0x02	; 2
   a0a:	88 e0       	ldi	r24, 0x08	; 8
   a0c:	8e 0f       	add	r24, r30
  			 *  \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;
   a0e:	90 91 f1 00 	lds	r25, 0x00F1
  	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();
   a12:	91 93       	st	Z+, r25
  	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++)
   a14:	8e 13       	cpse	r24, r30
   a16:	fb cf       	rjmp	.-10     	; 0xa0e <USB_Device_ProcessControlRequest+0x1e>
  	  *(RequestHeader++) = Endpoint_Read_8();
  	#endif
  
  	EVENT_USB_Device_ControlRequest();
   a18:	89 dc       	rcall	.-1774   	; 0x32c <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);
   a1a:	80 91 e8 00 	lds	r24, 0x00E8
  
  	if (Endpoint_IsSETUPReceived())
   a1e:	83 ff       	sbrs	r24, 3
   a20:	28 c1       	rjmp	.+592    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  	{
  		uint8_t bmRequestType = USB_ControlRequest.bmRequestType;
   a22:	80 91 38 02 	lds	r24, 0x0238
  
  		switch (USB_ControlRequest.bRequest)
   a26:	90 91 39 02 	lds	r25, 0x0239
   a2a:	95 30       	cpi	r25, 0x05	; 5
   a2c:	09 f4       	brne	.+2      	; 0xa30 <USB_Device_ProcessControlRequest+0x40>
   a2e:	83 c0       	rjmp	.+262    	; 0xb36 <USB_Device_ProcessControlRequest+0x146>
   a30:	30 f4       	brcc	.+12     	; 0xa3e <USB_Device_ProcessControlRequest+0x4e>
   a32:	91 30       	cpi	r25, 0x01	; 1
   a34:	a9 f1       	breq	.+106    	; 0xaa0 <USB_Device_ProcessControlRequest+0xb0>
   a36:	68 f0       	brcs	.+26     	; 0xa52 <USB_Device_ProcessControlRequest+0x62>
   a38:	93 30       	cpi	r25, 0x03	; 3
   a3a:	91 f1       	breq	.+100    	; 0xaa0 <USB_Device_ProcessControlRequest+0xb0>
   a3c:	1a c1       	rjmp	.+564    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
   a3e:	98 30       	cpi	r25, 0x08	; 8
   a40:	09 f4       	brne	.+2      	; 0xa44 <USB_Device_ProcessControlRequest+0x54>
   a42:	ed c0       	rjmp	.+474    	; 0xc1e <USB_Device_ProcessControlRequest+0x22e>
   a44:	99 30       	cpi	r25, 0x09	; 9
   a46:	09 f4       	brne	.+2      	; 0xa4a <USB_Device_ProcessControlRequest+0x5a>
   a48:	f9 c0       	rjmp	.+498    	; 0xc3c <USB_Device_ProcessControlRequest+0x24c>
   a4a:	96 30       	cpi	r25, 0x06	; 6
   a4c:	09 f0       	breq	.+2      	; 0xa50 <USB_Device_ProcessControlRequest+0x60>
   a4e:	11 c1       	rjmp	.+546    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
   a50:	93 c0       	rjmp	.+294    	; 0xb78 <USB_Device_ProcessControlRequest+0x188>
  		{
  			case REQ_GetStatus:
  				if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
   a52:	80 38       	cpi	r24, 0x80	; 128
   a54:	21 f0       	breq	.+8      	; 0xa5e <USB_Device_ProcessControlRequest+0x6e>
   a56:	82 38       	cpi	r24, 0x82	; 130
   a58:	09 f0       	breq	.+2      	; 0xa5c <USB_Device_ProcessControlRequest+0x6c>
   a5a:	0b c1       	rjmp	.+534    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
   a5c:	08 c0       	rjmp	.+16     	; 0xa6e <USB_Device_ProcessControlRequest+0x7e>
  	Endpoint_ClearOUT();
  }
  
  static void USB_Device_GetStatus(void)
  {
  	uint8_t CurrentStatus = 0;
   a5e:	80 91 35 02 	lds	r24, 0x0235
  			if (USB_Device_CurrentlySelfPowered)
  			  CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
  			#endif
  
  			#if !defined(NO_DEVICE_REMOTE_WAKEUP)
  			if (USB_Device_RemoteWakeupEnabled)
   a62:	90 91 36 02 	lds	r25, 0x0236
   a66:	99 23       	and	r25, r25
   a68:	89 f0       	breq	.+34     	; 0xa8c <USB_Device_ProcessControlRequest+0x9c>
  			  CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
   a6a:	82 60       	ori	r24, 0x02	; 2
   a6c:	0f c0       	rjmp	.+30     	; 0xa8c <USB_Device_ProcessControlRequest+0x9c>
  			break;
  		}
  		case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
  		{
  			#if !defined(CONTROL_ONLY_DEVICE)
  			uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
   a6e:	80 91 3c 02 	lds	r24, 0x023C
   a72:	8f 70       	andi	r24, 0x0F	; 15
  
  			if (EndpointIndex >= ENDPOINT_TOTAL_ENDPOINTS)
   a74:	85 30       	cpi	r24, 0x05	; 5
   a76:	08 f0       	brcs	.+2      	; 0xa7a <USB_Device_ProcessControlRequest+0x8a>
   a78:	fc c0       	rjmp	.+504    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  			 */
  			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);
   a7a:	80 93 e9 00 	sts	0x00E9, 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);
   a7e:	80 91 eb 00 	lds	r24, 0x00EB
   a82:	85 fb       	bst	r24, 5
   a84:	88 27       	eor	r24, r24
   a86:	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);
   a88:	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);
   a8c:	90 91 e8 00 	lds	r25, 0x00E8
   a90:	97 7f       	andi	r25, 0xF7	; 247
   a92:	90 93 e8 00 	sts	0x00E8, 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);
   a96:	80 93 f1 00 	sts	0x00F1, r24
  				UEDATX = (Data >> 8);
   a9a:	10 92 f1 00 	sts	0x00F1, r1
   a9e:	ca c0       	rjmp	.+404    	; 0xc34 <USB_Device_ProcessControlRequest+0x244>
  				}
  
  				break;
  			case REQ_ClearFeature:
  			case REQ_SetFeature:
  				if ((bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE)) ||
   aa0:	28 2f       	mov	r18, r24
   aa2:	2d 7f       	andi	r18, 0xFD	; 253
   aa4:	09 f0       	breq	.+2      	; 0xaa8 <USB_Device_ProcessControlRequest+0xb8>
   aa6:	e5 c0       	rjmp	.+458    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  	Endpoint_ClearStatusStage();
  }
  
  static void USB_Device_ClearSetFeature(void)
  {
  	switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
   aa8:	88 23       	and	r24, r24
   aaa:	19 f0       	breq	.+6      	; 0xab2 <USB_Device_ProcessControlRequest+0xc2>
   aac:	82 30       	cpi	r24, 0x02	; 2
   aae:	61 f0       	breq	.+24     	; 0xac8 <USB_Device_ProcessControlRequest+0xd8>
   ab0:	e0 c0       	rjmp	.+448    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  	{
  		#if !defined(NO_DEVICE_REMOTE_WAKEUP)
  		case REQREC_DEVICE:
  		{
  			if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_DeviceRemoteWakeup)
   ab2:	80 91 3a 02 	lds	r24, 0x023A
   ab6:	81 30       	cpi	r24, 0x01	; 1
   ab8:	09 f0       	breq	.+2      	; 0xabc <USB_Device_ProcessControlRequest+0xcc>
   aba:	db c0       	rjmp	.+438    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  			  USB_Device_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
   abc:	93 30       	cpi	r25, 0x03	; 3
   abe:	09 f0       	breq	.+2      	; 0xac2 <USB_Device_ProcessControlRequest+0xd2>
   ac0:	80 e0       	ldi	r24, 0x00	; 0
   ac2:	80 93 36 02 	sts	0x0236, r24
   ac6:	2e c0       	rjmp	.+92     	; 0xb24 <USB_Device_ProcessControlRequest+0x134>
  		}
  		#endif
  		#if !defined(CONTROL_ONLY_DEVICE)
  		case REQREC_ENDPOINT:
  		{
  			if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_EndpointHalt)
   ac8:	80 91 3a 02 	lds	r24, 0x023A
   acc:	81 11       	cpse	r24, r1
   ace:	2a c0       	rjmp	.+84     	; 0xb24 <USB_Device_ProcessControlRequest+0x134>
  			{
  				uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
   ad0:	80 91 3c 02 	lds	r24, 0x023C
   ad4:	8f 70       	andi	r24, 0x0F	; 15
  
  				if (EndpointIndex == ENDPOINT_CONTROLEP || EndpointIndex >= ENDPOINT_TOTAL_ENDPOINTS)
   ad6:	2f ef       	ldi	r18, 0xFF	; 255
   ad8:	28 0f       	add	r18, r24
   ada:	24 30       	cpi	r18, 0x04	; 4
   adc:	08 f0       	brcs	.+2      	; 0xae0 <USB_Device_ProcessControlRequest+0xf0>
   ade:	c9 c0       	rjmp	.+402    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  			 */
  			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);
   ae0:	80 93 e9 00 	sts	0x00E9, r24
  			 * \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);
   ae4:	20 91 eb 00 	lds	r18, 0x00EB
  				  return;
  
  				Endpoint_SelectEndpoint(EndpointIndex);
  
  				if (Endpoint_IsEnabled())
   ae8:	20 ff       	sbrs	r18, 0
   aea:	1c c0       	rjmp	.+56     	; 0xb24 <USB_Device_ProcessControlRequest+0x134>
  				{
  					if (USB_ControlRequest.bRequest == REQ_SetFeature)
   aec:	93 30       	cpi	r25, 0x03	; 3
   aee:	21 f4       	brne	.+8      	; 0xaf8 <USB_Device_ProcessControlRequest+0x108>
  			 *  \ingroup Group_EndpointPacketManagement_AVR8
  			 */
  			static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;
  			static inline void Endpoint_StallTransaction(void)
  			{
  				UECONX |= (1 << STALLRQ);
   af0:	80 91 eb 00 	lds	r24, 0x00EB
   af4:	80 62       	ori	r24, 0x20	; 32
   af6:	14 c0       	rjmp	.+40     	; 0xb20 <USB_Device_ProcessControlRequest+0x130>
  			 *  \ingroup Group_EndpointPacketManagement_AVR8
  			 */
  			static inline void Endpoint_ClearStall(void) ATTR_ALWAYS_INLINE;
  			static inline void Endpoint_ClearStall(void)
  			{
  				UECONX |= (1 << STALLRQC);
   af8:	90 91 eb 00 	lds	r25, 0x00EB
   afc:	90 61       	ori	r25, 0x10	; 16
   afe:	90 93 eb 00 	sts	0x00EB, r25
  			 *  \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));
   b02:	21 e0       	ldi	r18, 0x01	; 1
   b04:	30 e0       	ldi	r19, 0x00	; 0
   b06:	a9 01       	movw	r20, r18
   b08:	02 c0       	rjmp	.+4      	; 0xb0e <USB_Device_ProcessControlRequest+0x11e>
   b0a:	44 0f       	add	r20, r20
   b0c:	55 1f       	adc	r21, r21
   b0e:	8a 95       	dec	r24
   b10:	e2 f7       	brpl	.-8      	; 0xb0a <USB_Device_ProcessControlRequest+0x11a>
   b12:	40 93 ea 00 	sts	0x00EA, r20
  				UERST = 0;
   b16:	10 92 ea 00 	sts	0x00EA, 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);
   b1a:	80 91 eb 00 	lds	r24, 0x00EB
   b1e:	88 60       	ori	r24, 0x08	; 8
   b20:	80 93 eb 00 	sts	0x00EB, 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);
   b24:	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);
   b28:	80 91 e8 00 	lds	r24, 0x00E8
   b2c:	87 7f       	andi	r24, 0xF7	; 247
   b2e:	80 93 e8 00 	sts	0x00E8, r24
  
  	Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
  
  	Endpoint_ClearSETUP();
  
  	Endpoint_ClearStatusStage();
   b32:	e2 dd       	rcall	.-1084   	; 0x6f8 <Endpoint_ClearStatusStage>
   b34:	9e c0       	rjmp	.+316    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  					USB_Device_ClearSetFeature();
  				}
  
  				break;
  			case REQ_SetAddress:
  				if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
   b36:	81 11       	cpse	r24, r1
   b38:	9c c0       	rjmp	.+312    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  	}
  }
  
  static void USB_Device_SetAddress(void)
  {
  	uint8_t DeviceAddress = (USB_ControlRequest.wValue & 0x7F);
   b3a:	10 91 3a 02 	lds	r17, 0x023A
   b3e:	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);
   b40:	80 91 e3 00 	lds	r24, 0x00E3
   b44:	80 78       	andi	r24, 0x80	; 128
   b46:	81 2b       	or	r24, r17
   b48:	80 93 e3 00 	sts	0x00E3, r24
   b4c:	80 91 e8 00 	lds	r24, 0x00E8
   b50:	87 7f       	andi	r24, 0xF7	; 247
   b52:	80 93 e8 00 	sts	0x00E8, r24
  
  	USB_Device_SetDeviceAddress(DeviceAddress);
  
  	Endpoint_ClearSETUP();
  
  	Endpoint_ClearStatusStage();
   b56:	d0 dd       	rcall	.-1120   	; 0x6f8 <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);
   b58:	80 91 e8 00 	lds	r24, 0x00E8
  
  	while (!(Endpoint_IsINReady()));
   b5c:	80 ff       	sbrs	r24, 0
   b5e:	fc cf       	rjmp	.-8      	; 0xb58 <USB_Device_ProcessControlRequest+0x168>
  			static inline void USB_Device_EnableDeviceAddress(const uint8_t Address) ATTR_ALWAYS_INLINE;
  			static inline void USB_Device_EnableDeviceAddress(const uint8_t Address)
  			{
  				(void)Address;
  
  				UDADDR |= (1 << ADDEN);
   b60:	80 91 e3 00 	lds	r24, 0x00E3
   b64:	80 68       	ori	r24, 0x80	; 128
   b66:	80 93 e3 00 	sts	0x00E3, r24
  
  	USB_Device_EnableDeviceAddress(DeviceAddress);
  
  	USB_DeviceState = (DeviceAddress) ? DEVICE_STATE_Addressed : DEVICE_STATE_Default;
   b6a:	11 11       	cpse	r17, r1
   b6c:	02 c0       	rjmp	.+4      	; 0xb72 <USB_Device_ProcessControlRequest+0x182>
   b6e:	82 e0       	ldi	r24, 0x02	; 2
   b70:	01 c0       	rjmp	.+2      	; 0xb74 <USB_Device_ProcessControlRequest+0x184>
   b72:	83 e0       	ldi	r24, 0x03	; 3
   b74:	8e bb       	out	0x1e, r24	; 30
   b76:	7d c0       	rjmp	.+250    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  				if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
  				  USB_Device_SetAddress();
  
  				break;
  			case REQ_GetDescriptor:
  				if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
   b78:	80 58       	subi	r24, 0x80	; 128
   b7a:	82 30       	cpi	r24, 0x02	; 2
   b7c:	08 f0       	brcs	.+2      	; 0xb80 <USB_Device_ProcessControlRequest+0x190>
   b7e:	79 c0       	rjmp	.+242    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  	    !(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))
   b80:	80 91 3a 02 	lds	r24, 0x023A
   b84:	90 91 3b 02 	lds	r25, 0x023B
   b88:	8c 3d       	cpi	r24, 0xDC	; 220
   b8a:	53 e0       	ldi	r21, 0x03	; 3
   b8c:	95 07       	cpc	r25, r21
   b8e:	71 f5       	brne	.+92     	; 0xbec <USB_Device_ProcessControlRequest+0x1fc>
  	{
  		USB_Descriptor_Header_t Header;
  		uint16_t                UnicodeString[INTERNAL_SERIAL_LENGTH_BITS / 4];
  	} SignatureDescriptor;
  
  	SignatureDescriptor.Header.Type = DTYPE_String;
   b90:	83 e0       	ldi	r24, 0x03	; 3
   b92:	8a 83       	std	Y+2, r24	; 0x02
  	SignatureDescriptor.Header.Size = USB_STRING_LEN(INTERNAL_SERIAL_LENGTH_BITS / 4);
   b94:	8a e2       	ldi	r24, 0x2A	; 42
   b96:	89 83       	std	Y+1, r24	; 0x01
  			static inline uint_reg_t GetGlobalInterruptMask(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				return SREG;
   b98:	4f b7       	in	r20, 0x3f	; 63
  			static inline void GlobalInterruptDisable(void)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				cli();
   b9a:	f8 94       	cli
  				__builtin_ssrf(AVR32_SR_GM_OFFSET);
  				#elif (ARCH == ARCH_XMEGA)
  				cli();
  				#endif
  
  				GCC_MEMORY_BARRIER();
   b9c:	de 01       	movw	r26, r28
   b9e:	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++)
   ba0:	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;
   ba2:	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);
   ba4:	51 e2       	ldi	r21, 0x21	; 33
   ba6:	e3 2f       	mov	r30, r19
   ba8:	f0 e0       	ldi	r31, 0x00	; 0
   baa:	50 93 57 00 	sts	0x0057, r21
   bae:	e4 91       	lpm	r30, Z
  
  					if (SerialCharNum & 0x01)
   bb0:	20 ff       	sbrs	r18, 0
   bb2:	03 c0       	rjmp	.+6      	; 0xbba <USB_Device_ProcessControlRequest+0x1ca>
  					{
  						SerialByte >>= 4;
   bb4:	e2 95       	swap	r30
   bb6:	ef 70       	andi	r30, 0x0F	; 15
  						SigReadAddress++;
   bb8:	3f 5f       	subi	r19, 0xFF	; 255
  					}
  
  					SerialByte &= 0x0F;
   bba:	ef 70       	andi	r30, 0x0F	; 15
   bbc:	8e 2f       	mov	r24, r30
   bbe:	90 e0       	ldi	r25, 0x00	; 0
  
  					UnicodeString[SerialCharNum] = cpu_to_le16((SerialByte >= 10) ?
   bc0:	ea 30       	cpi	r30, 0x0A	; 10
   bc2:	10 f0       	brcs	.+4      	; 0xbc8 <USB_Device_ProcessControlRequest+0x1d8>
   bc4:	c7 96       	adiw	r24, 0x37	; 55
   bc6:	01 c0       	rjmp	.+2      	; 0xbca <USB_Device_ProcessControlRequest+0x1da>
   bc8:	c0 96       	adiw	r24, 0x30	; 48
   bca:	8d 93       	st	X+, r24
   bcc:	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++)
   bce:	2f 5f       	subi	r18, 0xFF	; 255
   bd0:	24 31       	cpi	r18, 0x14	; 20
   bd2:	49 f7       	brne	.-46     	; 0xba6 <USB_Device_ProcessControlRequest+0x1b6>
  			static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
  			{
  				GCC_MEMORY_BARRIER();
  
  				#if (ARCH == ARCH_AVR8)
  				SREG = GlobalIntState;
   bd4:	4f bf       	out	0x3f, r20	; 63
  			 *  \note This is not applicable for non CONTROL type endpoints.
  			 */
  			static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
  			static inline void Endpoint_ClearSETUP(void)
  			{
  				UEINTX &= ~(1 << RXSTPI);
   bd6:	80 91 e8 00 	lds	r24, 0x00E8
   bda:	87 7f       	andi	r24, 0xF7	; 247
   bdc:	80 93 e8 00 	sts	0x00E8, r24
  
  	USB_Device_GetSerialString(SignatureDescriptor.UnicodeString);
  
  	Endpoint_ClearSETUP();
  
  	Endpoint_Write_Control_Stream_LE(&SignatureDescriptor, sizeof(SignatureDescriptor));
   be0:	6a e2       	ldi	r22, 0x2A	; 42
   be2:	70 e0       	ldi	r23, 0x00	; 0
   be4:	ce 01       	movw	r24, r28
   be6:	01 96       	adiw	r24, 0x01	; 1
   be8:	53 dc       	rcall	.-1882   	; 0x490 <Endpoint_Write_Control_Stream_LE>
   bea:	13 c0       	rjmp	.+38     	; 0xc12 <USB_Device_ProcessControlRequest+0x222>
  		USB_Device_GetInternalSerialDescriptor();
  		return;
  	}
  	#endif
  
  	if ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex,
   bec:	60 91 3c 02 	lds	r22, 0x023C
   bf0:	70 91 3d 02 	lds	r23, 0x023D
   bf4:	ae 01       	movw	r20, r28
   bf6:	4f 5f       	subi	r20, 0xFF	; 255
   bf8:	5f 4f       	sbci	r21, 0xFF	; 255
   bfa:	18 dc       	rcall	.-2000   	; 0x42c <CALLBACK_USB_GetDescriptor>
   bfc:	bc 01       	movw	r22, r24
   bfe:	89 2b       	or	r24, r25
   c00:	c1 f1       	breq	.+112    	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
   c02:	90 91 e8 00 	lds	r25, 0x00E8
   c06:	97 7f       	andi	r25, 0xF7	; 247
   c08:	90 93 e8 00 	sts	0x00E8, r25
  	#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);
   c0c:	89 81       	ldd	r24, Y+1	; 0x01
   c0e:	9a 81       	ldd	r25, Y+2	; 0x02
   c10:	9b dc       	rcall	.-1738   	; 0x548 <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));
   c12:	80 91 e8 00 	lds	r24, 0x00E8
   c16:	8b 77       	andi	r24, 0x7B	; 123
   c18:	80 93 e8 00 	sts	0x00E8, r24
   c1c:	2a c0       	rjmp	.+84     	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  					USB_Device_GetDescriptor();
  				}
  
  				break;
  			case REQ_GetConfiguration:
  				if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
   c1e:	80 38       	cpi	r24, 0x80	; 128
   c20:	41 f5       	brne	.+80     	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  			 *  \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);
   c22:	80 91 e8 00 	lds	r24, 0x00E8
   c26:	87 7f       	andi	r24, 0xF7	; 247
   c28:	80 93 e8 00 	sts	0x00E8, r24
  
  static void USB_Device_GetConfiguration(void)
  {
  	Endpoint_ClearSETUP();
  
  	Endpoint_Write_8(USB_Device_ConfigurationNumber);
   c2c:	80 91 34 02 	lds	r24, 0x0234
  			 *  \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;
   c30:	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));
   c34:	80 91 e8 00 	lds	r24, 0x00E8
   c38:	8e 77       	andi	r24, 0x7E	; 126
   c3a:	79 cf       	rjmp	.-270    	; 0xb2e <USB_Device_ProcessControlRequest+0x13e>
  				if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
  				  USB_Device_GetConfiguration();
  
  				break;
  			case REQ_SetConfiguration:
  				if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
   c3c:	81 11       	cpse	r24, r1
   c3e:	19 c0       	rjmp	.+50     	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  }
  
  static void USB_Device_SetConfiguration(void)
  {
  	#if defined(FIXED_NUM_CONFIGURATIONS)
  	if ((uint8_t)USB_ControlRequest.wValue > FIXED_NUM_CONFIGURATIONS)
   c40:	90 91 3a 02 	lds	r25, 0x023A
   c44:	92 30       	cpi	r25, 0x02	; 2
   c46:	a8 f4       	brcc	.+42     	; 0xc72 <USB_Device_ProcessControlRequest+0x282>
  			 *  \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);
   c48:	80 91 e8 00 	lds	r24, 0x00E8
   c4c:	87 7f       	andi	r24, 0xF7	; 247
   c4e:	80 93 e8 00 	sts	0x00E8, r24
  	#endif
  	#endif
  
  	Endpoint_ClearSETUP();
  
  	USB_Device_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
   c52:	90 93 34 02 	sts	0x0234, r25
  
  	Endpoint_ClearStatusStage();
   c56:	50 dd       	rcall	.-1376   	; 0x6f8 <Endpoint_ClearStatusStage>
  
  	if (USB_Device_ConfigurationNumber)
   c58:	80 91 34 02 	lds	r24, 0x0234
   c5c:	81 11       	cpse	r24, r1
   c5e:	06 c0       	rjmp	.+12     	; 0xc6c <USB_Device_ProcessControlRequest+0x27c>
  			}
  
  			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));
   c60:	80 91 e3 00 	lds	r24, 0x00E3
  	  USB_DeviceState = DEVICE_STATE_Configured;
  	else
  	  USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered;
   c64:	87 fd       	sbrc	r24, 7
   c66:	02 c0       	rjmp	.+4      	; 0xc6c <USB_Device_ProcessControlRequest+0x27c>
   c68:	81 e0       	ldi	r24, 0x01	; 1
   c6a:	01 c0       	rjmp	.+2      	; 0xc6e <USB_Device_ProcessControlRequest+0x27e>
   c6c:	84 e0       	ldi	r24, 0x04	; 4
   c6e:	8e bb       	out	0x1e, r24	; 30
  
  	EVENT_USB_Device_ConfigurationChanged();
   c70:	54 db       	rcall	.-2392   	; 0x31a <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);
   c72:	80 91 e8 00 	lds	r24, 0x00E8
  			default:
  				break;
  		}
  	}
  
  	if (Endpoint_IsSETUPReceived())
   c76:	83 ff       	sbrs	r24, 3
   c78:	0a c0       	rjmp	.+20     	; 0xc8e <USB_Device_ProcessControlRequest+0x29e>
  			 *  \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);
   c7a:	80 91 e8 00 	lds	r24, 0x00E8
   c7e:	87 7f       	andi	r24, 0xF7	; 247
   c80:	80 93 e8 00 	sts	0x00E8, r24
  			 *  \ingroup Group_EndpointPacketManagement_AVR8
  			 */
  			static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;
  			static inline void Endpoint_StallTransaction(void)
  			{
  				UECONX |= (1 << STALLRQ);
   c84:	80 91 eb 00 	lds	r24, 0x00EB
   c88:	80 62       	ori	r24, 0x20	; 32
   c8a:	80 93 eb 00 	sts	0x00EB, r24
  	{
  		Endpoint_ClearSETUP();
  		Endpoint_StallTransaction();
  	}
  }
   c8e:	aa 96       	adiw	r28, 0x2a	; 42
   c90:	0f b6       	in	r0, 0x3f	; 63
   c92:	f8 94       	cli
   c94:	de bf       	out	0x3e, r29	; 62
   c96:	0f be       	out	0x3f, r0	; 63
   c98:	cd bf       	out	0x3d, r28	; 61
   c9a:	df 91       	pop	r29
   c9c:	cf 91       	pop	r28
   c9e:	1f 91       	pop	r17
   ca0:	08 95       	ret
  
  00000ca2 <USB_Event_Stub>:
  #define  __INCLUDE_FROM_EVENTS_C
  #define  __INCLUDE_FROM_USB_DRIVER
  #include "Events.h"
  
  void USB_Event_Stub(void)
  {
   ca2:	08 95       	ret
  
  00000ca4 <USB_USBTask>:
  #if defined(USB_CAN_BE_DEVICE) && !defined(DEVICE_STATE_AS_GPIOR)
  volatile uint8_t     USB_DeviceState;
  #endif
  
  void USB_USBTask(void)
  {
   ca4:	cf 93       	push	r28
  }
  
  #if defined(USB_CAN_BE_DEVICE)
  static void USB_DeviceTask(void)
  {
  	if (USB_DeviceState == DEVICE_STATE_Unattached)
   ca6:	8e b3       	in	r24, 0x1e	; 30
   ca8:	88 23       	and	r24, r24
   caa:	99 f0       	breq	.+38     	; 0xcd2 <USB_USBTask+0x2e>
  			 */
  			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());
   cac:	c0 91 e9 00 	lds	r28, 0x00E9
   cb0:	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;
   cb2:	90 91 ec 00 	lds	r25, 0x00EC
   cb6:	89 2f       	mov	r24, r25
   cb8:	81 70       	andi	r24, 0x01	; 1
   cba:	90 fd       	sbrc	r25, 0
   cbc:	80 e8       	ldi	r24, 0x80	; 128
  			 */
  			static inline uint8_t Endpoint_GetCurrentEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
  			static inline uint8_t Endpoint_GetCurrentEndpoint(void)
  			{
  				#if !defined(CONTROL_ONLY_DEVICE)
  					return ((UENUM & ENDPOINT_EPNUM_MASK) | Endpoint_GetEndpointDirection());
   cbe:	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);
   cc0:	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);
   cc4:	80 91 e8 00 	lds	r24, 0x00E8
  
  	uint8_t PrevEndpoint = Endpoint_GetCurrentEndpoint();
  
  	Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
  
  	if (Endpoint_IsSETUPReceived())
   cc8:	83 fd       	sbrc	r24, 3
  	  USB_Device_ProcessControlRequest();
   cca:	92 de       	rcall	.-732    	; 0x9f0 <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);
   ccc:	cf 70       	andi	r28, 0x0F	; 15
   cce:	c0 93 e9 00 	sts	0x00E9, r28
  	#elif defined(USB_CAN_BE_HOST)
  		USB_HostTask();
  	#elif defined(USB_CAN_BE_DEVICE)
  		USB_DeviceTask();
  	#endif
  }
   cd2:	cf 91       	pop	r28
   cd4:	08 95       	ret
  
  00000cd6 <CDC_Device_ConfigureEndpoints>:
  
  void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
                                       FILE* const Stream)
  {
  	*Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar_Blocking, _FDEV_SETUP_RW);
  	fdev_set_udata(Stream, CDCInterfaceInfo);
   cd6:	cf 93       	push	r28
   cd8:	df 93       	push	r29
   cda:	ec 01       	movw	r28, r24
   cdc:	fc 01       	movw	r30, r24
   cde:	70 96       	adiw	r30, 0x10	; 16
   ce0:	8b e0       	ldi	r24, 0x0B	; 11
   ce2:	df 01       	movw	r26, r30
   ce4:	1d 92       	st	X+, r1
   ce6:	8a 95       	dec	r24
   ce8:	e9 f7       	brne	.-6      	; 0xce4 <CDC_Device_ConfigureEndpoints+0xe>
   cea:	82 e0       	ldi	r24, 0x02	; 2
   cec:	8c 83       	std	Y+4, r24	; 0x04
   cee:	89 87       	std	Y+9, r24	; 0x09
   cf0:	83 e0       	ldi	r24, 0x03	; 3
   cf2:	8e 87       	std	Y+14, r24	; 0x0e
   cf4:	61 e0       	ldi	r22, 0x01	; 1
   cf6:	ce 01       	movw	r24, r28
   cf8:	01 96       	adiw	r24, 0x01	; 1
   cfa:	b5 dc       	rcall	.-1686   	; 0x666 <Endpoint_ConfigureEndpointTable>
   cfc:	88 23       	and	r24, r24
   cfe:	61 f0       	breq	.+24     	; 0xd18 <CDC_Device_ConfigureEndpoints+0x42>
   d00:	61 e0       	ldi	r22, 0x01	; 1
   d02:	ce 01       	movw	r24, r28
   d04:	06 96       	adiw	r24, 0x06	; 6
   d06:	af dc       	rcall	.-1698   	; 0x666 <Endpoint_ConfigureEndpointTable>
   d08:	88 23       	and	r24, r24
   d0a:	31 f0       	breq	.+12     	; 0xd18 <CDC_Device_ConfigureEndpoints+0x42>
   d0c:	61 e0       	ldi	r22, 0x01	; 1
   d0e:	ce 01       	movw	r24, r28
   d10:	0b 96       	adiw	r24, 0x0b	; 11
   d12:	df 91       	pop	r29
   d14:	cf 91       	pop	r28
   d16:	a7 cc       	rjmp	.-1714   	; 0x666 <Endpoint_ConfigureEndpointTable>
   d18:	80 e0       	ldi	r24, 0x00	; 0
   d1a:	df 91       	pop	r29
   d1c:	cf 91       	pop	r28
   d1e:	08 95       	ret
  
  00000d20 <CDC_Device_SendByte>:
   d20:	0f 93       	push	r16
   d22:	1f 93       	push	r17
   d24:	cf 93       	push	r28
   d26:	2e b3       	in	r18, 0x1e	; 30
   d28:	24 30       	cpi	r18, 0x04	; 4
   d2a:	f9 f4       	brne	.+62     	; 0xd6a <CDC_Device_SendByte+0x4a>
   d2c:	fc 01       	movw	r30, r24
   d2e:	04 89       	ldd	r16, Z+20	; 0x14
   d30:	15 89       	ldd	r17, Z+21	; 0x15
   d32:	26 89       	ldd	r18, Z+22	; 0x16
   d34:	37 89       	ldd	r19, Z+23	; 0x17
   d36:	01 2b       	or	r16, r17
   d38:	02 2b       	or	r16, r18
   d3a:	03 2b       	or	r16, r19
   d3c:	b1 f0       	breq	.+44     	; 0xd6a <CDC_Device_SendByte+0x4a>
   d3e:	c6 2f       	mov	r28, r22
   d40:	81 81       	ldd	r24, Z+1	; 0x01
   d42:	8f 70       	andi	r24, 0x0F	; 15
   d44:	80 93 e9 00 	sts	0x00E9, r24
   d48:	80 91 e8 00 	lds	r24, 0x00E8
   d4c:	85 ff       	sbrs	r24, 5
   d4e:	04 c0       	rjmp	.+8      	; 0xd58 <CDC_Device_SendByte+0x38>
   d50:	c0 93 f1 00 	sts	0x00F1, r28
   d54:	80 e0       	ldi	r24, 0x00	; 0
   d56:	0a c0       	rjmp	.+20     	; 0xd6c <CDC_Device_SendByte+0x4c>
   d58:	80 91 e8 00 	lds	r24, 0x00E8
   d5c:	8e 77       	andi	r24, 0x7E	; 126
   d5e:	80 93 e8 00 	sts	0x00E8, r24
   d62:	e7 dc       	rcall	.-1586   	; 0x732 <Endpoint_WaitUntilReady>
   d64:	88 23       	and	r24, r24
   d66:	a1 f3       	breq	.-24     	; 0xd50 <CDC_Device_SendByte+0x30>
   d68:	01 c0       	rjmp	.+2      	; 0xd6c <CDC_Device_SendByte+0x4c>
   d6a:	82 e0       	ldi	r24, 0x02	; 2
   d6c:	cf 91       	pop	r28
   d6e:	1f 91       	pop	r17
   d70:	0f 91       	pop	r16
   d72:	08 95       	ret
  
  00000d74 <CDC_Device_Flush>:
   d74:	2e b3       	in	r18, 0x1e	; 30
   d76:	24 30       	cpi	r18, 0x04	; 4
   d78:	21 f5       	brne	.+72     	; 0xdc2 <CDC_Device_Flush+0x4e>
   d7a:	fc 01       	movw	r30, r24
   d7c:	44 89       	ldd	r20, Z+20	; 0x14
   d7e:	55 89       	ldd	r21, Z+21	; 0x15
   d80:	66 89       	ldd	r22, Z+22	; 0x16
   d82:	77 89       	ldd	r23, Z+23	; 0x17
   d84:	45 2b       	or	r20, r21
   d86:	46 2b       	or	r20, r22
   d88:	47 2b       	or	r20, r23
   d8a:	d9 f0       	breq	.+54     	; 0xdc2 <CDC_Device_Flush+0x4e>
   d8c:	81 81       	ldd	r24, Z+1	; 0x01
   d8e:	8f 70       	andi	r24, 0x0F	; 15
   d90:	80 93 e9 00 	sts	0x00E9, r24
   d94:	80 91 f2 00 	lds	r24, 0x00F2
   d98:	88 23       	and	r24, r24
   d9a:	89 f0       	breq	.+34     	; 0xdbe <CDC_Device_Flush+0x4a>
   d9c:	90 91 e8 00 	lds	r25, 0x00E8
   da0:	80 91 e8 00 	lds	r24, 0x00E8
   da4:	8e 77       	andi	r24, 0x7E	; 126
   da6:	80 93 e8 00 	sts	0x00E8, r24
   daa:	95 fd       	sbrc	r25, 5
   dac:	08 c0       	rjmp	.+16     	; 0xdbe <CDC_Device_Flush+0x4a>
   dae:	c1 dc       	rcall	.-1662   	; 0x732 <Endpoint_WaitUntilReady>
   db0:	81 11       	cpse	r24, r1
   db2:	08 c0       	rjmp	.+16     	; 0xdc4 <CDC_Device_Flush+0x50>
   db4:	80 91 e8 00 	lds	r24, 0x00E8
   db8:	8e 77       	andi	r24, 0x7E	; 126
   dba:	80 93 e8 00 	sts	0x00E8, r24
   dbe:	80 e0       	ldi	r24, 0x00	; 0
   dc0:	08 95       	ret
   dc2:	82 e0       	ldi	r24, 0x02	; 2
   dc4:	08 95       	ret
  
  00000dc6 <CDC_Device_USBTask>:
   dc6:	2e b3       	in	r18, 0x1e	; 30
   dc8:	24 30       	cpi	r18, 0x04	; 4
   dca:	89 f4       	brne	.+34     	; 0xdee <CDC_Device_USBTask+0x28>
   dcc:	fc 01       	movw	r30, r24
   dce:	44 89       	ldd	r20, Z+20	; 0x14
   dd0:	55 89       	ldd	r21, Z+21	; 0x15
   dd2:	66 89       	ldd	r22, Z+22	; 0x16
   dd4:	77 89       	ldd	r23, Z+23	; 0x17
   dd6:	45 2b       	or	r20, r21
   dd8:	46 2b       	or	r20, r22
   dda:	47 2b       	or	r20, r23
   ddc:	41 f0       	breq	.+16     	; 0xdee <CDC_Device_USBTask+0x28>
   dde:	21 81       	ldd	r18, Z+1	; 0x01
   de0:	2f 70       	andi	r18, 0x0F	; 15
   de2:	20 93 e9 00 	sts	0x00E9, r18
   de6:	20 91 e8 00 	lds	r18, 0x00E8
   dea:	20 fd       	sbrc	r18, 0
   dec:	c3 cf       	rjmp	.-122    	; 0xd74 <CDC_Device_Flush>
   dee:	08 95       	ret
  
  00000df0 <CDC_Device_ReceiveByte>:
   df0:	2e b3       	in	r18, 0x1e	; 30
   df2:	24 30       	cpi	r18, 0x04	; 4
   df4:	19 f0       	breq	.+6      	; 0xdfc <CDC_Device_ReceiveByte+0xc>
   df6:	8f ef       	ldi	r24, 0xFF	; 255
   df8:	9f ef       	ldi	r25, 0xFF	; 255
   dfa:	08 95       	ret
   dfc:	fc 01       	movw	r30, r24
   dfe:	44 89       	ldd	r20, Z+20	; 0x14
   e00:	55 89       	ldd	r21, Z+21	; 0x15
   e02:	66 89       	ldd	r22, Z+22	; 0x16
   e04:	77 89       	ldd	r23, Z+23	; 0x17
   e06:	45 2b       	or	r20, r21
   e08:	46 2b       	or	r20, r22
   e0a:	47 2b       	or	r20, r23
   e0c:	a1 f3       	breq	.-24     	; 0xdf6 <CDC_Device_ReceiveByte+0x6>
   e0e:	86 81       	ldd	r24, Z+6	; 0x06
   e10:	8f 70       	andi	r24, 0x0F	; 15
   e12:	80 93 e9 00 	sts	0x00E9, r24
   e16:	80 91 e8 00 	lds	r24, 0x00E8
   e1a:	82 ff       	sbrs	r24, 2
   e1c:	ec cf       	rjmp	.-40     	; 0xdf6 <CDC_Device_ReceiveByte+0x6>
   e1e:	80 91 f2 00 	lds	r24, 0x00F2
   e22:	88 23       	and	r24, r24
   e24:	21 f0       	breq	.+8      	; 0xe2e <CDC_Device_ReceiveByte+0x3e>
   e26:	20 91 f1 00 	lds	r18, 0x00F1
   e2a:	30 e0       	ldi	r19, 0x00	; 0
   e2c:	02 c0       	rjmp	.+4      	; 0xe32 <CDC_Device_ReceiveByte+0x42>
   e2e:	2f ef       	ldi	r18, 0xFF	; 255
   e30:	3f ef       	ldi	r19, 0xFF	; 255
   e32:	80 91 f2 00 	lds	r24, 0x00F2
   e36:	81 11       	cpse	r24, r1
   e38:	05 c0       	rjmp	.+10     	; 0xe44 <CDC_Device_ReceiveByte+0x54>
   e3a:	80 91 e8 00 	lds	r24, 0x00E8
   e3e:	8b 77       	andi	r24, 0x7B	; 123
   e40:	80 93 e8 00 	sts	0x00E8, r24
   e44:	c9 01       	movw	r24, r18
   e46:	08 95       	ret
  
  00000e48 <CDC_Device_Event_Stub>:
  	return ReceivedByte;
  }
  #endif
  
  void CDC_Device_Event_Stub(void)
  {
   e48:	08 95       	ret
  
  00000e4a <CDC_Device_ProcessControlRequest>:
  #define  __INCLUDE_FROM_CDC_DRIVER
  #define  __INCLUDE_FROM_CDC_DEVICE_C
  #include "CDCClassDevice.h"
  
  void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
  {
   e4a:	cf 93       	push	r28
   e4c:	df 93       	push	r29
   e4e:	ec 01       	movw	r28, r24
  			 *  \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);
   e50:	80 91 e8 00 	lds	r24, 0x00E8
  	if (!(Endpoint_IsSETUPReceived()))
   e54:	83 ff       	sbrs	r24, 3
   e56:	a5 c0       	rjmp	.+330    	; 0xfa2 <CDC_Device_ProcessControlRequest+0x158>
  	  return;
  
  	if (USB_ControlRequest.wIndex != CDCInterfaceInfo->Config.ControlInterfaceNumber)
   e58:	88 81       	ld	r24, Y
   e5a:	90 e0       	ldi	r25, 0x00	; 0
   e5c:	20 91 3c 02 	lds	r18, 0x023C
   e60:	30 91 3d 02 	lds	r19, 0x023D
   e64:	28 17       	cp	r18, r24
   e66:	39 07       	cpc	r19, r25
   e68:	09 f0       	breq	.+2      	; 0xe6c <CDC_Device_ProcessControlRequest+0x22>
   e6a:	9b c0       	rjmp	.+310    	; 0xfa2 <CDC_Device_ProcessControlRequest+0x158>
  	  return;
  
  	switch (USB_ControlRequest.bRequest)
   e6c:	80 91 39 02 	lds	r24, 0x0239
   e70:	81 32       	cpi	r24, 0x21	; 33
   e72:	61 f0       	breq	.+24     	; 0xe8c <CDC_Device_ProcessControlRequest+0x42>
   e74:	20 f4       	brcc	.+8      	; 0xe7e <CDC_Device_ProcessControlRequest+0x34>
   e76:	80 32       	cpi	r24, 0x20	; 32
   e78:	09 f4       	brne	.+2      	; 0xe7c <CDC_Device_ProcessControlRequest+0x32>
   e7a:	3e c0       	rjmp	.+124    	; 0xef8 <CDC_Device_ProcessControlRequest+0xae>
   e7c:	92 c0       	rjmp	.+292    	; 0xfa2 <CDC_Device_ProcessControlRequest+0x158>
   e7e:	82 32       	cpi	r24, 0x22	; 34
   e80:	09 f4       	brne	.+2      	; 0xe84 <CDC_Device_ProcessControlRequest+0x3a>
   e82:	6b c0       	rjmp	.+214    	; 0xf5a <CDC_Device_ProcessControlRequest+0x110>
   e84:	83 32       	cpi	r24, 0x23	; 35
   e86:	09 f4       	brne	.+2      	; 0xe8a <CDC_Device_ProcessControlRequest+0x40>
   e88:	7c c0       	rjmp	.+248    	; 0xf82 <CDC_Device_ProcessControlRequest+0x138>
   e8a:	8b c0       	rjmp	.+278    	; 0xfa2 <CDC_Device_ProcessControlRequest+0x158>
  	{
  		case CDC_REQ_GetLineEncoding:
  			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
   e8c:	80 91 38 02 	lds	r24, 0x0238
   e90:	81 3a       	cpi	r24, 0xA1	; 161
   e92:	09 f0       	breq	.+2      	; 0xe96 <CDC_Device_ProcessControlRequest+0x4c>
   e94:	86 c0       	rjmp	.+268    	; 0xfa2 <CDC_Device_ProcessControlRequest+0x158>
  			 *  \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);
   e96:	80 91 e8 00 	lds	r24, 0x00E8
   e9a:	87 7f       	andi	r24, 0xF7	; 247
   e9c:	80 93 e8 00 	sts	0x00E8, r24
  			 *  \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);
   ea0:	80 91 e8 00 	lds	r24, 0x00E8
  			{
  				Endpoint_ClearSETUP();
  
  				while (!(Endpoint_IsINReady()));
   ea4:	80 ff       	sbrs	r24, 0
   ea6:	fc cf       	rjmp	.-8      	; 0xea0 <CDC_Device_ProcessControlRequest+0x56>
  
  				Endpoint_Write_32_LE(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
   ea8:	8c 89       	ldd	r24, Y+20	; 0x14
   eaa:	9d 89       	ldd	r25, Y+21	; 0x15
   eac:	ae 89       	ldd	r26, Y+22	; 0x16
   eae:	bf 89       	ldd	r27, Y+23	; 0x17
  			 *  \param[in] Data  Data to write to the currently selected endpoint's FIFO buffer.
  			 */
  			static inline void Endpoint_Write_32_LE(const uint32_t Data) ATTR_ALWAYS_INLINE;
  			static inline void Endpoint_Write_32_LE(const uint32_t Data)
  			{
  				UEDATX = (Data &  0xFF);
   eb0:	80 93 f1 00 	sts	0x00F1, r24
  				UEDATX = (Data >> 8);
   eb4:	49 2f       	mov	r20, r25
   eb6:	5a 2f       	mov	r21, r26
   eb8:	6b 2f       	mov	r22, r27
   eba:	77 27       	eor	r23, r23
   ebc:	40 93 f1 00 	sts	0x00F1, r20
  				UEDATX = (Data >> 16);
   ec0:	ad 01       	movw	r20, r26
   ec2:	66 27       	eor	r22, r22
   ec4:	77 27       	eor	r23, r23
   ec6:	40 93 f1 00 	sts	0x00F1, r20
  				UEDATX = (Data >> 24);
   eca:	8b 2f       	mov	r24, r27
   ecc:	99 27       	eor	r25, r25
   ece:	aa 27       	eor	r26, r26
   ed0:	bb 27       	eor	r27, r27
   ed2:	80 93 f1 00 	sts	0x00F1, r24
  				Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.CharFormat);
   ed6:	88 8d       	ldd	r24, Y+24	; 0x18
  			 *  \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;
   ed8:	80 93 f1 00 	sts	0x00F1, r24
  				Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.ParityType);
   edc:	89 8d       	ldd	r24, Y+25	; 0x19
   ede:	80 93 f1 00 	sts	0x00F1, r24
  				Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.DataBits);
   ee2:	8a 8d       	ldd	r24, Y+26	; 0x1a
   ee4:	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));
   ee8:	80 91 e8 00 	lds	r24, 0x00E8
   eec:	8e 77       	andi	r24, 0x7E	; 126
   eee:	80 93 e8 00 	sts	0x00E8, r24
  				EVENT_CDC_Device_BreakSent(CDCInterfaceInfo, (uint8_t)USB_ControlRequest.wValue);
  			}
  
  			break;
  	}
  }
   ef2:	df 91       	pop	r29
   ef4:	cf 91       	pop	r28
  				Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.CharFormat);
  				Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.ParityType);
  				Endpoint_Write_8(CDCInterfaceInfo->State.LineEncoding.DataBits);
  
  				Endpoint_ClearIN();
  				Endpoint_ClearStatusStage();
   ef6:	00 cc       	rjmp	.-2048   	; 0x6f8 <Endpoint_ClearStatusStage>
  			}
  
  			break;
  		case CDC_REQ_SetLineEncoding:
  			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
   ef8:	80 91 38 02 	lds	r24, 0x0238
   efc:	81 32       	cpi	r24, 0x21	; 33
   efe:	09 f0       	breq	.+2      	; 0xf02 <CDC_Device_ProcessControlRequest+0xb8>
   f00:	50 c0       	rjmp	.+160    	; 0xfa2 <CDC_Device_ProcessControlRequest+0x158>
  			 *  \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);
   f02:	80 91 e8 00 	lds	r24, 0x00E8
   f06:	87 7f       	andi	r24, 0xF7	; 247
   f08:	80 93 e8 00 	sts	0x00E8, 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);
   f0c:	80 91 e8 00 	lds	r24, 0x00E8
  			{
  				Endpoint_ClearSETUP();
  
  				while (!(Endpoint_IsOUTReceived()))
   f10:	82 fd       	sbrc	r24, 2
   f12:	04 c0       	rjmp	.+8      	; 0xf1c <CDC_Device_ProcessControlRequest+0xd2>
  				{
  					if (USB_DeviceState == DEVICE_STATE_Unattached)
   f14:	8e b3       	in	r24, 0x1e	; 30
   f16:	81 11       	cpse	r24, r1
   f18:	f9 cf       	rjmp	.-14     	; 0xf0c <CDC_Device_ProcessControlRequest+0xc2>
   f1a:	43 c0       	rjmp	.+134    	; 0xfa2 <CDC_Device_ProcessControlRequest+0x158>
  				{
  					uint32_t Value;
  					uint8_t  Bytes[4];
  				} Data;
  
  				Data.Bytes[0] = UEDATX;
   f1c:	30 91 f1 00 	lds	r19, 0x00F1
  				Data.Bytes[1] = UEDATX;
   f20:	20 91 f1 00 	lds	r18, 0x00F1
  				Data.Bytes[2] = UEDATX;
   f24:	90 91 f1 00 	lds	r25, 0x00F1
  				Data.Bytes[3] = UEDATX;
   f28:	80 91 f1 00 	lds	r24, 0x00F1
  					  return;
  				}
  
  				CDCInterfaceInfo->State.LineEncoding.BaudRateBPS = Endpoint_Read_32_LE();
   f2c:	3c 8b       	std	Y+20, r19	; 0x14
   f2e:	2d 8b       	std	Y+21, r18	; 0x15
   f30:	9e 8b       	std	Y+22, r25	; 0x16
   f32:	8f 8b       	std	Y+23, r24	; 0x17
  			 *  \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;
   f34:	80 91 f1 00 	lds	r24, 0x00F1
  				CDCInterfaceInfo->State.LineEncoding.CharFormat  = Endpoint_Read_8();
   f38:	88 8f       	std	Y+24, r24	; 0x18
   f3a:	80 91 f1 00 	lds	r24, 0x00F1
  				CDCInterfaceInfo->State.LineEncoding.ParityType  = Endpoint_Read_8();
   f3e:	89 8f       	std	Y+25, r24	; 0x19
   f40:	80 91 f1 00 	lds	r24, 0x00F1
  				CDCInterfaceInfo->State.LineEncoding.DataBits    = Endpoint_Read_8();
   f44:	8a 8f       	std	Y+26, r24	; 0x1a
  			 */
  			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));
   f46:	80 91 e8 00 	lds	r24, 0x00E8
   f4a:	8b 77       	andi	r24, 0x7B	; 123
   f4c:	80 93 e8 00 	sts	0x00E8, r24
  
  				Endpoint_ClearOUT();
  				Endpoint_ClearStatusStage();
   f50:	d3 db       	rcall	.-2138   	; 0x6f8 <Endpoint_ClearStatusStage>
  
  				EVENT_CDC_Device_LineEncodingChanged(CDCInterfaceInfo);
   f52:	ce 01       	movw	r24, r28
  				EVENT_CDC_Device_BreakSent(CDCInterfaceInfo, (uint8_t)USB_ControlRequest.wValue);
  			}
  
  			break;
  	}
  }
   f54:	df 91       	pop	r29
   f56:	cf 91       	pop	r28
  				CDCInterfaceInfo->State.LineEncoding.DataBits    = Endpoint_Read_8();
  
  				Endpoint_ClearOUT();
  				Endpoint_ClearStatusStage();
  
  				EVENT_CDC_Device_LineEncodingChanged(CDCInterfaceInfo);
   f58:	24 ca       	rjmp	.-3000   	; 0x3a2 <EVENT_CDC_Device_LineEncodingChanged>
  			}
  
  			break;
  		case CDC_REQ_SetControlLineState:
  			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
   f5a:	80 91 38 02 	lds	r24, 0x0238
   f5e:	81 32       	cpi	r24, 0x21	; 33
   f60:	01 f5       	brne	.+64     	; 0xfa2 <CDC_Device_ProcessControlRequest+0x158>
  			 *  \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);
   f62:	80 91 e8 00 	lds	r24, 0x00E8
   f66:	87 7f       	andi	r24, 0xF7	; 247
   f68:	80 93 e8 00 	sts	0x00E8, r24
  			{
  				Endpoint_ClearSETUP();
  				Endpoint_ClearStatusStage();
   f6c:	c5 db       	rcall	.-2166   	; 0x6f8 <Endpoint_ClearStatusStage>
  
  				CDCInterfaceInfo->State.ControlLineStates.HostToDevice = USB_ControlRequest.wValue;
   f6e:	80 91 3a 02 	lds	r24, 0x023A
   f72:	90 91 3b 02 	lds	r25, 0x023B
   f76:	99 8b       	std	Y+17, r25	; 0x11
   f78:	88 8b       	std	Y+16, r24	; 0x10
  
  				EVENT_CDC_Device_ControLineStateChanged(CDCInterfaceInfo);
   f7a:	ce 01       	movw	r24, r28
  				EVENT_CDC_Device_BreakSent(CDCInterfaceInfo, (uint8_t)USB_ControlRequest.wValue);
  			}
  
  			break;
  	}
  }
   f7c:	df 91       	pop	r29
   f7e:	cf 91       	pop	r28
  				Endpoint_ClearSETUP();
  				Endpoint_ClearStatusStage();
  
  				CDCInterfaceInfo->State.ControlLineStates.HostToDevice = USB_ControlRequest.wValue;
  
  				EVENT_CDC_Device_ControLineStateChanged(CDCInterfaceInfo);
   f80:	63 cf       	rjmp	.-314    	; 0xe48 <CDC_Device_Event_Stub>
  			}
  
  			break;
  		case CDC_REQ_SendBreak:
  			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
   f82:	80 91 38 02 	lds	r24, 0x0238
   f86:	81 32       	cpi	r24, 0x21	; 33
   f88:	61 f4       	brne	.+24     	; 0xfa2 <CDC_Device_ProcessControlRequest+0x158>
   f8a:	80 91 e8 00 	lds	r24, 0x00E8
   f8e:	87 7f       	andi	r24, 0xF7	; 247
   f90:	80 93 e8 00 	sts	0x00E8, r24
  			{
  				Endpoint_ClearSETUP();
  				Endpoint_ClearStatusStage();
   f94:	b1 db       	rcall	.-2206   	; 0x6f8 <Endpoint_ClearStatusStage>
  
  				EVENT_CDC_Device_BreakSent(CDCInterfaceInfo, (uint8_t)USB_ControlRequest.wValue);
   f96:	60 91 3a 02 	lds	r22, 0x023A
   f9a:	ce 01       	movw	r24, r28
  			}
  
  			break;
  	}
  }
   f9c:	df 91       	pop	r29
   f9e:	cf 91       	pop	r28
  			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  			{
  				Endpoint_ClearSETUP();
  				Endpoint_ClearStatusStage();
  
  				EVENT_CDC_Device_BreakSent(CDCInterfaceInfo, (uint8_t)USB_ControlRequest.wValue);
   fa0:	53 cf       	rjmp	.-346    	; 0xe48 <CDC_Device_Event_Stub>
  			}
  
  			break;
  	}
  }
   fa2:	df 91       	pop	r29
   fa4:	cf 91       	pop	r28
   fa6:	08 95       	ret
  
  00000fa8 <__udivmodsi4>:
   fa8:	a1 e2       	ldi	r26, 0x21	; 33
   faa:	1a 2e       	mov	r1, r26
   fac:	aa 1b       	sub	r26, r26
   fae:	bb 1b       	sub	r27, r27
   fb0:	fd 01       	movw	r30, r26
   fb2:	0d c0       	rjmp	.+26     	; 0xfce <__udivmodsi4_ep>
  
  00000fb4 <__udivmodsi4_loop>:
   fb4:	aa 1f       	adc	r26, r26
   fb6:	bb 1f       	adc	r27, r27
   fb8:	ee 1f       	adc	r30, r30
   fba:	ff 1f       	adc	r31, r31
   fbc:	a2 17       	cp	r26, r18
   fbe:	b3 07       	cpc	r27, r19
   fc0:	e4 07       	cpc	r30, r20
   fc2:	f5 07       	cpc	r31, r21
   fc4:	20 f0       	brcs	.+8      	; 0xfce <__udivmodsi4_ep>
   fc6:	a2 1b       	sub	r26, r18
   fc8:	b3 0b       	sbc	r27, r19
   fca:	e4 0b       	sbc	r30, r20
   fcc:	f5 0b       	sbc	r31, r21
  
  00000fce <__udivmodsi4_ep>:
   fce:	66 1f       	adc	r22, r22
   fd0:	77 1f       	adc	r23, r23
   fd2:	88 1f       	adc	r24, r24
   fd4:	99 1f       	adc	r25, r25
   fd6:	1a 94       	dec	r1
   fd8:	69 f7       	brne	.-38     	; 0xfb4 <__udivmodsi4_loop>
   fda:	60 95       	com	r22
   fdc:	70 95       	com	r23
   fde:	80 95       	com	r24
   fe0:	90 95       	com	r25
   fe2:	9b 01       	movw	r18, r22
   fe4:	ac 01       	movw	r20, r24
   fe6:	bd 01       	movw	r22, r26
   fe8:	cf 01       	movw	r24, r30
   fea:	08 95       	ret
  
  00000fec <_exit>:
   fec:	f8 94       	cli
  
  00000fee <__stop_program>:
   fee:	ff cf       	rjmp	.-2      	; 0xfee <__stop_program>