2f8:	30 f0       	brcs	.+12     	; 0x306 <get_kbchar+0x30>
		kb_outptr = kb_buffer;
 2fa:	8c ea       	ldi	r24, 0xAC	; 172
 2fc:	90 e0       	ldi	r25, 0x00	; 0
 2fe:	90 93 ef 00 	sts	0x00EF, r25
 302:	80 93 ee 00 	sts	0x00EE, r24

	// Decrement buffer count
	kb_buffcnt--;
 306:	80 91 ab 00 	lds	r24, 0x00AB
 30a:	81 50       	subi	r24, 0x01	; 1
 30c:	80 93 ab 00 	sts	0x00AB, r24

	SREG = tmp;
 310:	3f bf       	out	0x3f, r19	; 63

	return byte;
}
 312:	82 2f       	mov	r24, r18
 314:	90 e0       	ldi	r25, 0x00	; 0
 316:	08 95       	ret

00000318 <decode>:
}



void decode(uint8_t sc)
{
 318:	38 2f       	mov	r19, r24
	static uint8_t is_up = 0, mode = 0;
	static uint8_t shift = 0;
	uint8_t i, ch;

	if (!is_up)								  // Last data received was the up-key identifier
 31a:	80 91 64 00 	lds	r24, 0x0064
 31e:	88 23       	and	r24, r24
 320:	09 f0       	breq	.+2      	; 0x324 <decode+0xc>
 322:	9c c0       	rjmp	.+312    	; 0x45c <decode+0x144>
	{
		if(sc == 0xF0)						  // The up-key identifier
 324:	30 3f       	cpi	r19, 0xF0	; 240
 326:	21 f4       	brne	.+8      	; 0x330 <decode+0x18>
		{
			is_up = 1;
 328:	81 e0       	ldi	r24, 0x01	; 1
 32a:	80 93 64 00 	sts	0x0064, r24
 32e:	08 95       	ret
		}

		else if(sc == 0x12 || sc == 0x59)	  // Left SHIFT or Right SHIFT
 330:	32 31       	cpi	r19, 0x12	; 18
 332:	11 f0       	breq	.+4      	; 0x338 <decode+0x20>
 334:	39 35       	cpi	r19, 0x59	; 89
 336:	21 f4       	brne	.+8      	; 0x340 <decode+0x28>
		{
			shift = 1;
 338:	81 e0       	ldi	r24, 0x01	; 1
 33a:	80 93 62 00 	sts	0x0062, r24
 33e:	08 95       	ret
 340:	80 91 63 00 	lds	r24, 0x0063
		}

		else if(sc == 0x05)					  // F1
 344:	35 30       	cpi	r19, 0x05	; 5
 346:	71 f4       	brne	.+28     	; 0x364 <decode+0x4c>
		{
			if(mode == 0)
 348:	88 23       	and	r24, r24
 34a:	19 f4       	brne	.+6      	; 0x352 <decode+0x3a>
				mode = 1;					  // Enter scan code mode
 34c:	81 e0       	ldi	r24, 0x01	; 1
 34e:	80 93 63 00 	sts	0x0063, r24
			if(mode == 2)
 352:	80 91 63 00 	lds	r24, 0x0063
 356:	82 30       	cpi	r24, 0x02	; 2
 358:	09 f0       	breq	.+2      	; 0x35c <decode+0x44>
 35a:	98 c0       	rjmp	.+304    	; 0x48c <__stack+0x2d>
				mode = 3;					  // Leave scan code mode
 35c:	83 e0       	ldi	r24, 0x03	; 3
 35e:	80 93 63 00 	sts	0x0063, r24
 362:	08 95       	ret
		}

		else
		{
			if(mode == 0 || mode == 3)		  // If ASCII mode
 364:	88 23       	and	r24, r24
 366:	19 f0       	breq	.+6      	; 0x36e <decode+0x56>
 368:	83 30       	cpi	r24, 0x03	; 3
 36a:	09 f0       	breq	.+2      	; 0x36e <decode+0x56>
 36c:	3c c0       	rjmp	.+120    	; 0x3e6 <decode+0xce>
			{
				if(!shift)					  // If shift not pressed,
 36e:	80 91 62 00 	lds	r24, 0x0062
 372:	88 23       	and	r24, r24
 374:	11 f0       	breq	.+4      	; 0x37a <decode+0x62>
 376:	40 e0       	ldi	r20, 0x00	; 0
 378:	1a c0       	rjmp	.+52     	; 0x3ae <decode+0x96>
 37a:	40 e0       	ldi	r20, 0x00	; 0
 37c:	01 c0       	rjmp	.+2      	; 0x380 <decode+0x68>
				{							  // do a table look-up
					for(i = 0; (ch = pgm_read_byte(&unshifted[i][0])) != sc && ch; i++);
 37e:	4f 5f       	subi	r20, 0xFF	; 255
 380:	84 2f       	mov	r24, r20
 382:	90 e0       	ldi	r25, 0x00	; 0
 384:	88 0f       	add	r24, r24
 386:	99 1f       	adc	r25, r25
 388:	fc 01       	movw	r30, r24
 38a:	ea 5d       	subi	r30, 0xDA	; 218
 38c:	ff 4f       	sbci	r31, 0xFF	; 255
 38e:	24 91       	lpm	r18, Z+
 390:	23 17       	cp	r18, r19
 392:	49 f4       	brne	.+18     	; 0x3a6 <decode+0x8e>
					if (ch == sc)
					{
						put_kbbuff(pgm_read_byte(&unshifted[i][1]));
 394:	89 5d       	subi	r24, 0xD9	; 217
 396:	9f 4f       	sbci	r25, 0xFF	; 255
 398:	fc 01       	movw	r30, r24
 39a:	94 91       	lpm	r25, Z+
void put_kbbuff(uint8_t c)
{
	// uint8_t tmp = SREG;
	// cli();

	if (kb_buffcnt < KB_BUFF_SIZE)			  // If buffer not full
 39c:	80 91 ab 00 	lds	r24, 0x00AB
 3a0:	80 34       	cpi	r24, 0x40	; 64
 3a2:	d8 f0       	brcs	.+54     	; 0x3da <decode+0xc2>
 3a4:	08 95       	ret
		{
			if(mode == 0 || mode == 3)		  // If ASCII mode
			{
				if(!shift)					  // If shift not pressed,
				{							  // do a table look-up
					for(i = 0; (ch = pgm_read_byte(&unshifted[i][0])) != sc && ch; i++);
 3a6:	22 23       	and	r18, r18
 3a8:	51 f7       	brne	.-44     	; 0x37e <decode+0x66>
 3aa:	08 95       	ret
						put_kbbuff(pgm_read_byte(&unshifted[i][1]));
					}
				}							  // If shift pressed
				else
				{
					for(i = 0; (ch = pgm_read_byte(&shifted[i][0])) != sc && ch; i++);
 3ac:	4f 5f       	subi	r20, 0xFF	; 255
 3ae:	84 2f       	mov	r24, r20
 3b0:	90 e0       	ldi	r25, 0x00	; 0
 3b2:	88 0f       	add	r24, r24
 3b4:	99 1f       	adc	r25, r25
 3b6:	fc 01       	movw	r30, r24
 3b8:	e2 55       	subi	r30, 0x52	; 82
 3ba:	ff 4f       	sbci	r31, 0xFF	; 255
 3bc:	24 91       	lpm	r18, Z+
 3be:	23 17       	cp	r18, r19
 3c0:	49 f4       	brne	.+18     	; 0x3d4 <decode+0xbc>
					if (ch == sc)
					{
						put_kbbuff( pgm_read_byte(&shifted[i][1]));
 3c2:	81 55       	subi	r24, 0x51	; 81
 3c4:	9f 4f       	sbci	r25, 0xFF	; 255
 3c6:	fc 01       	movw	r30, r24
 3c8:	94 91       	lpm	r25, Z+
void put_kbbuff(uint8_t c)
{
	// uint8_t tmp = SREG;
	// cli();

	if (kb_buffcnt < KB_BUFF_SIZE)			  // If buffer not full
 3ca:	80 91 ab 00 	lds	r24, 0x00AB
 3ce:	80 34       	cpi	r24, 0x40	; 64
 3d0:	20 f0       	brcs	.+8      	; 0x3da <decode+0xc2>
 3d2:	08 95       	ret
						put_kbbuff(pgm_read_byte(&unshifted[i][1]));
					}
				}							  // If shift pressed
				else
				{
					for(i = 0; (ch = pgm_read_byte(&shifted[i][0])) != sc && ch; i++);
 3d4:	22 23       	and	r18, r18
 3d6:	51 f7       	brne	.-44     	; 0x3ac <decode+0x94>
 3d8:	08 95       	ret

	if (kb_buffcnt < KB_BUFF_SIZE)			  // If buffer not full
	{
		// Put character into buffer
		// Increment pointer
		*kb_inptr++ = c;
 3da:	e0 91 ec 00 	lds	r30, 0x00EC
 3de:	f0 91 ed 00 	lds	r31, 0x00ED
 3e2:	91 93       	st	Z+, r25
 3e4:	28 c0       	rjmp	.+80     	; 0x436 <decode+0x11e>
					}
				}
			}								  // Scan code mode
			else
			{
				print_hexbyte(sc);			  // Print scan code
 3e6:	83 2f       	mov	r24, r19
 3e8:	29 df       	rcall	.-430    	; 0x23c <print_hexbyte>
void put_kbbuff(uint8_t c)
{
	// uint8_t tmp = SREG;
	// cli();

	if (kb_buffcnt < KB_BUFF_SIZE)			  // If buffer not full
 3ea:	80 91 ab 00 	lds	r24, 0x00AB
 3ee:	80 34       	cpi	r24, 0x40	; 64
 3f0:	c0 f4       	brcc	.+48     	; 0x422 <decode+0x10a>
	{
		// Put character into buffer
		// Increment pointer
		*kb_inptr++ = c;
 3f2:	e0 91 ec 00 	lds	r30, 0x00EC
 3f6:	f0 91 ed 00 	lds	r31, 0x00ED
 3fa:	80 e2       	ldi	r24, 0x20	; 32
 3fc:	81 93       	st	Z+, r24
 3fe:	f0 93 ed 00 	sts	0x00ED, r31
 402:	e0 93 ec 00 	sts	0x00EC, r30
		kb_buffcnt++;
 406:	80 91 ab 00 	lds	r24, 0x00AB
 40a:	8f 5f       	subi	r24, 0xFF	; 255
 40c:	80 93 ab 00 	sts	0x00AB, r24

		// Pointer wrapping
		if (kb_inptr >= kb_buffer + KB_BUFF_SIZE)
 410:	ec 5e       	subi	r30, 0xEC	; 236
 412:	f0 40       	sbci	r31, 0x00	; 0
 414:	30 f0       	brcs	.+12     	; 0x422 <decode+0x10a>
			kb_inptr = kb_buffer;
 416:	8c ea       	ldi	r24, 0xAC	; 172
 418:	90 e0       	ldi	r25, 0x00	; 0
 41a:	90 93 ed 00 	sts	0x00ED, r25
 41e:	80 93 ec 00 	sts	0x00EC, r24
void put_kbbuff(uint8_t c)
{
	// uint8_t tmp = SREG;
	// cli();

	if (kb_buffcnt < KB_BUFF_SIZE)			  // If buffer not full
 422:	80 91 ab 00 	lds	r24, 0x00AB
 426:	80 34       	cpi	r24, 0x40	; 64
 428:	88 f5       	brcc	.+98     	; 0x48c <__stack+0x2d>
	{
		// Put character into buffer
		// Increment pointer
		*kb_inptr++ = c;
 42a:	e0 91 ec 00 	lds	r30, 0x00EC
 42e:	f0 91 ed 00 	lds	r31, 0x00ED
 432:	80 e2       	ldi	r24, 0x20	; 32
 434:	81 93       	st	Z+, r24
 436:	f0 93 ed 00 	sts	0x00ED, r31
 43a:	e0 93 ec 00 	sts	0x00EC, r30
		kb_buffcnt++;
 43e:	80 91 ab 00 	lds	r24, 0x00AB
 442:	8f 5f       	subi	r24, 0xFF	; 255
 444:	80 93 ab 00 	sts	0x00AB, r24

		// Pointer wrapping
		if (kb_inptr >= kb_buffer + KB_BUFF_SIZE)
 448:	ec 5e       	subi	r30, 0xEC	; 236
 44a:	f0 40       	sbci	r31, 0x00	; 0
 44c:	f8 f0       	brcs	.+62     	; 0x48c <__stack+0x2d>
			kb_inptr = kb_buffer;
 44e:	8c ea       	ldi	r24, 0xAC	; 172
 450:	90 e0       	ldi	r25, 0x00	; 0
 452:	90 93 ed 00 	sts	0x00ED, r25
 456:	80 93 ec 00 	sts	0x00EC, r24
 45a:	08 95       	ret
			}
		}
	}
	else
	{
		is_up = 0;							  // Two 0xF0 in a row not allowed
 45c:	10 92 64 00 	sts	0x0064, r1

		if(sc == 0x12 || sc == 0x59)		  // Left SHIFT or Right SHIFT
 460:	32 31       	cpi	r19, 0x12	; 18
 462:	11 f0       	breq	.+4      	; 0x468 <__stack+0x9>
 464:	39 35       	cpi	r19, 0x59	; 89
 466:	19 f4       	brne	.+6      	; 0x46e <__stack+0xf>
		{
			shift = 0;
 468:	10 92 62 00 	sts	0x0062, r1
 46c:	08 95       	ret
		}

		else if(sc == 0x05)					  // F1
 46e:	35 30       	cpi	r19, 0x05	; 5
 470:	69 f4       	brne	.+26     	; 0x48c <__stack+0x2d>
		{
			if(mode == 1)
 472:	80 91 63 00 	lds	r24, 0x0063
 476:	81 30       	cpi	r24, 0x01	; 1
 478:	19 f4       	brne	.+6      	; 0x480 <__stack+0x21>
				mode = 2;
 47a:	82 e0       	ldi	r24, 0x02	; 2
 47c:	80 93 63 00 	sts	0x0063, r24
			if(mode == 3)
 480:	80 91 63 00 	lds	r24, 0x0063
 484:	83 30       	cpi	r24, 0x03	; 3
 486:	11 f4       	brne	.+4      	; 0x48c <__stack+0x2d>
				mode = 0;
 488:	10 92 63 00 	sts	0x0063, r1
 48c:	08 95       	ret

0000048e <__vector_1>:




ISR (INT0_vect)
{
 48e:	1f 92       	push	r1
 490:	0f 92       	push	r0
 492:	0f b6       	in	r0, 0x3f	; 63
 494:	0f 92       	push	r0
 496:	11 24       	eor	r1, r1
 498:	2f 93       	push	r18
 49a:	3f 93       	push	r19
 49c:	4f 93       	push	r20
 49e:	5f 93       	push	r21
 4a0:	6f 93       	push	r22
 4a2:	7f 93       	push	r23
 4a4:	8f 93       	push	r24
 4a6:	9f 93       	push	r25
 4a8:	af 93       	push	r26
 4aa:	bf 93       	push	r27
 4ac:	ef 93       	push	r30
 4ae:	ff 93       	push	r31
	static uint8_t data = 0;				  // Holds the received scan code
	static uint8_t bitcount = 11;			  // 0 = neg.  1 = pos.

	if(bitcount < 11 && bitcount > 2)		  // Bit 3 to 10 is data. Parity bit,
 4b0:	90 91 60 00 	lds	r25, 0x0060
 4b4:	89 2f       	mov	r24, r25
 4b6:	83 50       	subi	r24, 0x03	; 3
 4b8:	88 30       	cpi	r24, 0x08	; 8
 4ba:	50 f4       	brcc	.+20     	; 0x4d0 <__vector_1+0x42>
	{										  // start and stop bits are ignored.
		data = (data >> 1);
 4bc:	80 91 65 00 	lds	r24, 0x0065
 4c0:	86 95       	lsr	r24
 4c2:	80 93 65 00 	sts	0x0065, r24
		if(PIND & (1 << DATAPIN))
 4c6:	83 9b       	sbis	0x10, 3	; 16
 4c8:	03 c0       	rjmp	.+6      	; 0x4d0 <__vector_1+0x42>
			data = data | 0x80;				  // Store a '1'
 4ca:	80 68       	ori	r24, 0x80	; 128
 4cc:	80 93 65 00 	sts	0x0065, r24
	}

	if(--bitcount == 0)						  // All bits received
 4d0:	89 2f       	mov	r24, r25
 4d2:	81 50       	subi	r24, 0x01	; 1
 4d4:	80 93 60 00 	sts	0x0060, r24
 4d8:	88 23       	and	r24, r24
 4da:	31 f4       	brne	.+12     	; 0x4e8 <__vector_1+0x5a>
	{
		bitcount = 11;
 4dc:	8b e0       	ldi	r24, 0x0B	; 11
 4de:	80 93 60 00 	sts	0x0060, r24
		decode(data);
 4e2:	80 91 65 00 	lds	r24, 0x0065
 4e6:	18 df       	rcall	.-464    	; 0x318 <decode>
	}
}
 4e8:	ff 91       	pop	r31
 4ea:	ef 91       	pop	r30
 4ec:	bf 91       	pop	r27
 4ee:	af 91       	pop	r26
 4f0:	9f 91       	pop	r25
 4f2:	8f 91       	pop	r24
 4f4:	7f 91       	pop	r23
 4f6:	6f 91       	pop	r22
 4f8:	5f 91       	pop	r21
 4fa:	4f 91       	pop	r20
 4fc:	3f 91       	pop	r19
 4fe:	2f 91       	pop	r18
 500:	0f 90       	pop	r0
 502:	0f be       	out	0x3f, r0	; 63
 504:	0f 90       	pop	r0
 506:	1f 90       	pop	r1
 508:	18 95       	reti

0000050a <main>:
{

	uint8_t key;

	// Initializes UART transmit buffer and keyboard reception
	init_uart();
 50a:	31 de       	rcall	.-926    	; 0x16e <init_uart>
	init_kb();
 50c:	b6 de       	rcall	.-660    	; 0x27a <init_kb>
	sei();
 50e:	78 94       	sei

	while(1)
	{
		key = get_kbchar();
 510:	e2 de       	rcall	.-572    	; 0x2d6 <get_kbchar>
		putchar(key);
 512:	90 e0       	ldi	r25, 0x00	; 0
 514:	3d de       	rcall	.-902    	; 0x190 <putchar>
 516:	fc cf       	rjmp	.-8      	; 0x510 <main+0x6>

00000518 <_exit>:
 518:	f8 94       	cli

0000051a <__stop_program>:
 51a:	ff cf       	rjmp	.-2      	; 0x51a <__stop_program>