
NewSoftSerial.o:     file format elf32-avr

Disassembly of section .text._ZN13NewSoftSerial10tunedDelayEj:

00000000 <_ZN13NewSoftSerial10tunedDelayEj>:
/******************************************************************************
* Private methods
******************************************************************************/
#if (F_CPU == 16000000 || F_CPU == 8000000)
/* static */ 
void NewSoftSerial::tunedDelay(uint16_t delay) { 
   0:	20 e0       	ldi	r18, 0x00	; 0
   2:	01 97       	sbiw	r24, 0x01	; 1
   4:	2f ef       	ldi	r18, 0xFF	; 255
   6:	8f 3f       	cpi	r24, 0xFF	; 255
   8:	92 07       	cpc	r25, r18
   a:	01 f4       	brne	.+0      	; 0xc <_ZN13NewSoftSerial10tunedDelayEj+0xc>
    "cpc %B0, %1 \n\t"
    "brne .-10 \n\t"
    : "+r" (delay), "+a" (tmp)
    : "0" (delay)
    );
}
   c:	08 95       	ret
Disassembly of section .text._ZN13NewSoftSerial8activateEv:

00000000 <_ZN13NewSoftSerial8activateEv>:
#endif

// This function sets the current object as the "active"
// one and returns true if it replaces another 
bool NewSoftSerial::activate(void)
   0:	fc 01       	movw	r30, r24
{
  if (active_object != this)
   2:	80 91 00 00 	lds	r24, 0x0000
   6:	90 91 00 00 	lds	r25, 0x0000
   a:	8e 17       	cp	r24, r30
   c:	9f 07       	cpc	r25, r31
   e:	01 f4       	brne	.+0      	; 0x10 <_ZN13NewSoftSerial8activateEv+0x10>
  10:	80 e0       	ldi	r24, 0x00	; 0
  12:	08 95       	ret
  {
    _buffer_overflow = false;
  14:	17 82       	std	Z+7, r1	; 0x07
    uint8_t oldSREG = SREG;
  16:	9f b7       	in	r25, 0x3f	; 63
    cli();
  18:	f8 94       	cli
    _receive_buffer_head = _receive_buffer_tail = 0;
  1a:	10 92 00 00 	sts	0x0000, r1
  1e:	80 91 00 00 	lds	r24, 0x0000
  22:	80 93 00 00 	sts	0x0000, r24
    active_object = this;
  26:	f0 93 00 00 	sts	0x0000, r31
  2a:	e0 93 00 00 	sts	0x0000, r30
    SREG = oldSREG;
  2e:	9f bf       	out	0x3f, r25	; 63
  30:	81 e0       	ldi	r24, 0x01	; 1
    return true;
  }

  return false;
}
  32:	08 95       	ret
Disassembly of section .text._ZN13NewSoftSerial5beginEl:

00000000 <_ZN13NewSoftSerial5beginEl>:
  _receivePin = rx;
  pinMode(_receivePin, INPUT); 
  digitalWrite(_receivePin, HIGH);  // pullup!
}

void NewSoftSerial::begin(long speed)
   0:	fc 01       	movw	r30, r24
{
  _txDelta = 0;
   2:	16 82       	std	Z+6, r1	; 0x06
  switch (speed) 
   4:	40 34       	cpi	r20, 0x40	; 64
   6:	88 e3       	ldi	r24, 0x38	; 56
   8:	58 07       	cpc	r21, r24
   a:	80 e0       	ldi	r24, 0x00	; 0
   c:	68 07       	cpc	r22, r24
   e:	80 e0       	ldi	r24, 0x00	; 0
  10:	78 07       	cpc	r23, r24
  12:	01 f4       	brne	.+0      	; 0x14 <_ZN13NewSoftSerial5beginEl+0x14>
  14:	00 c0       	rjmp	.+0      	; 0x16 <_ZN13NewSoftSerial5beginEl+0x16>
  16:	41 34       	cpi	r20, 0x41	; 65
  18:	88 e3       	ldi	r24, 0x38	; 56
  1a:	58 07       	cpc	r21, r24
  1c:	80 e0       	ldi	r24, 0x00	; 0
  1e:	68 07       	cpc	r22, r24
  20:	80 e0       	ldi	r24, 0x00	; 0
  22:	78 07       	cpc	r23, r24
  24:	04 f4       	brge	.+0      	; 0x26 <_ZN13NewSoftSerial5beginEl+0x26>
  26:	40 36       	cpi	r20, 0x60	; 96
  28:	89 e0       	ldi	r24, 0x09	; 9
  2a:	58 07       	cpc	r21, r24
  2c:	80 e0       	ldi	r24, 0x00	; 0
  2e:	68 07       	cpc	r22, r24
  30:	80 e0       	ldi	r24, 0x00	; 0
  32:	78 07       	cpc	r23, r24
  34:	01 f4       	brne	.+0      	; 0x36 <_ZN13NewSoftSerial5beginEl+0x36>
  36:	00 c0       	rjmp	.+0      	; 0x38 <_ZN13NewSoftSerial5beginEl+0x38>
  38:	41 36       	cpi	r20, 0x61	; 97
  3a:	89 e0       	ldi	r24, 0x09	; 9
  3c:	58 07       	cpc	r21, r24
  3e:	80 e0       	ldi	r24, 0x00	; 0
  40:	68 07       	cpc	r22, r24
  42:	80 e0       	ldi	r24, 0x00	; 0
  44:	78 07       	cpc	r23, r24
  46:	04 f4       	brge	.+0      	; 0x48 <_ZN13NewSoftSerial5beginEl+0x48>
  48:	4c 32       	cpi	r20, 0x2C	; 44
  4a:	81 e0       	ldi	r24, 0x01	; 1
  4c:	58 07       	cpc	r21, r24
  4e:	80 e0       	ldi	r24, 0x00	; 0
  50:	68 07       	cpc	r22, r24
  52:	80 e0       	ldi	r24, 0x00	; 0
  54:	78 07       	cpc	r23, r24
  56:	01 f4       	brne	.+0      	; 0x58 <_ZN13NewSoftSerial5beginEl+0x58>
  58:	00 c0       	rjmp	.+0      	; 0x5a <_ZN13NewSoftSerial5beginEl+0x5a>
  5a:	40 3b       	cpi	r20, 0xB0	; 176
  5c:	84 e0       	ldi	r24, 0x04	; 4
  5e:	58 07       	cpc	r21, r24
  60:	80 e0       	ldi	r24, 0x00	; 0
  62:	68 07       	cpc	r22, r24
  64:	80 e0       	ldi	r24, 0x00	; 0
  66:	78 07       	cpc	r23, r24
  68:	01 f0       	breq	.+0      	; 0x6a <_ZN13NewSoftSerial5beginEl+0x6a>
  6a:	00 c0       	rjmp	.+0      	; 0x6c <_ZN13NewSoftSerial5beginEl+0x6c>
  6c:	00 c0       	rjmp	.+0      	; 0x6e <_ZN13NewSoftSerial5beginEl+0x6e>
  6e:	40 3c       	cpi	r20, 0xC0	; 192
  70:	82 e1       	ldi	r24, 0x12	; 18
  72:	58 07       	cpc	r21, r24
  74:	80 e0       	ldi	r24, 0x00	; 0
  76:	68 07       	cpc	r22, r24
  78:	80 e0       	ldi	r24, 0x00	; 0
  7a:	78 07       	cpc	r23, r24
  7c:	01 f4       	brne	.+0      	; 0x7e <_ZN13NewSoftSerial5beginEl+0x7e>
  7e:	00 c0       	rjmp	.+0      	; 0x80 <_ZN13NewSoftSerial5beginEl+0x80>
  80:	40 38       	cpi	r20, 0x80	; 128
  82:	85 e2       	ldi	r24, 0x25	; 37
  84:	58 07       	cpc	r21, r24
  86:	80 e0       	ldi	r24, 0x00	; 0
  88:	68 07       	cpc	r22, r24
  8a:	80 e0       	ldi	r24, 0x00	; 0
  8c:	78 07       	cpc	r23, r24
  8e:	01 f0       	breq	.+0      	; 0x90 <_ZN13NewSoftSerial5beginEl+0x90>
  90:	00 c0       	rjmp	.+0      	; 0x92 <_ZN13NewSoftSerial5beginEl+0x92>
  92:	00 c0       	rjmp	.+0      	; 0x94 <_ZN13NewSoftSerial5beginEl+0x94>
  94:	42 31       	cpi	r20, 0x12	; 18
  96:	8a e7       	ldi	r24, 0x7A	; 122
  98:	58 07       	cpc	r21, r24
  9a:	80 e0       	ldi	r24, 0x00	; 0
  9c:	68 07       	cpc	r22, r24
  9e:	80 e0       	ldi	r24, 0x00	; 0
  a0:	78 07       	cpc	r23, r24
  a2:	01 f4       	brne	.+0      	; 0xa4 <_ZN13NewSoftSerial5beginEl+0xa4>
  a4:	00 c0       	rjmp	.+0      	; 0xa6 <_ZN13NewSoftSerial5beginEl+0xa6>
  a6:	43 31       	cpi	r20, 0x13	; 19
  a8:	8a e7       	ldi	r24, 0x7A	; 122
  aa:	58 07       	cpc	r21, r24
  ac:	80 e0       	ldi	r24, 0x00	; 0
  ae:	68 07       	cpc	r22, r24
  b0:	80 e0       	ldi	r24, 0x00	; 0
  b2:	78 07       	cpc	r23, r24
  b4:	04 f4       	brge	.+0      	; 0xb6 <_ZN13NewSoftSerial5beginEl+0xb6>
  b6:	40 30       	cpi	r20, 0x00	; 0
  b8:	8b e4       	ldi	r24, 0x4B	; 75
  ba:	58 07       	cpc	r21, r24
  bc:	80 e0       	ldi	r24, 0x00	; 0
  be:	68 07       	cpc	r22, r24
  c0:	80 e0       	ldi	r24, 0x00	; 0
  c2:	78 07       	cpc	r23, r24
  c4:	01 f0       	breq	.+0      	; 0xc6 <_ZN13NewSoftSerial5beginEl+0xc6>
  c6:	40 38       	cpi	r20, 0x80	; 128
  c8:	80 e7       	ldi	r24, 0x70	; 112
  ca:	58 07       	cpc	r21, r24
  cc:	80 e0       	ldi	r24, 0x00	; 0
  ce:	68 07       	cpc	r22, r24
  d0:	80 e0       	ldi	r24, 0x00	; 0
  d2:	78 07       	cpc	r23, r24
  d4:	01 f0       	breq	.+0      	; 0xd6 <_ZN13NewSoftSerial5beginEl+0xd6>
  d6:	00 c0       	rjmp	.+0      	; 0xd8 <_ZN13NewSoftSerial5beginEl+0xd8>
  d8:	00 c0       	rjmp	.+0      	; 0xda <_ZN13NewSoftSerial5beginEl+0xda>
  da:	40 30       	cpi	r20, 0x00	; 0
  dc:	81 ee       	ldi	r24, 0xE1	; 225
  de:	58 07       	cpc	r21, r24
  e0:	80 e0       	ldi	r24, 0x00	; 0
  e2:	68 07       	cpc	r22, r24
  e4:	80 e0       	ldi	r24, 0x00	; 0
  e6:	78 07       	cpc	r23, r24
  e8:	01 f0       	breq	.+0      	; 0xea <_ZN13NewSoftSerial5beginEl+0xea>
  ea:	40 30       	cpi	r20, 0x00	; 0
  ec:	82 ec       	ldi	r24, 0xC2	; 194
  ee:	58 07       	cpc	r21, r24
  f0:	81 e0       	ldi	r24, 0x01	; 1
  f2:	68 07       	cpc	r22, r24
  f4:	80 e0       	ldi	r24, 0x00	; 0
  f6:	78 07       	cpc	r23, r24
  f8:	01 f0       	breq	.+0      	; 0xfa <_ZN13NewSoftSerial5beginEl+0xfa>
  fa:	40 30       	cpi	r20, 0x00	; 0
  fc:	86 e9       	ldi	r24, 0x96	; 150
  fe:	58 07       	cpc	r21, r24
 100:	80 e0       	ldi	r24, 0x00	; 0
 102:	68 07       	cpc	r22, r24
 104:	80 e0       	ldi	r24, 0x00	; 0
 106:	78 07       	cpc	r23, r24
 108:	01 f4       	brne	.+0      	; 0x10a <_ZN13NewSoftSerial5beginEl+0x10a>
 10a:	00 c0       	rjmp	.+0      	; 0x10c <_ZN13NewSoftSerial5beginEl+0x10c>
  {
  case 115200: // For xmit -only-!
    _bitDelay = 8; break;
 10c:	88 e0       	ldi	r24, 0x08	; 8
 10e:	90 e0       	ldi	r25, 0x00	; 0
 110:	00 c0       	rjmp	.+0      	; 0x112 <_ZN13NewSoftSerial5beginEl+0x112>
  case 57600:
    _txDelta = -3;
 112:	8d ef       	ldi	r24, 0xFD	; 253
 114:	86 83       	std	Z+6, r24	; 0x06
    _bitDelay = 31; break;
 116:	8f e1       	ldi	r24, 0x1F	; 31
 118:	90 e0       	ldi	r25, 0x00	; 0
 11a:	95 83       	std	Z+5, r25	; 0x05
 11c:	84 83       	std	Z+4, r24	; 0x04
 11e:	00 c0       	rjmp	.+0      	; 0x120 <_ZN13NewSoftSerial5beginEl+0x120>
  case 38400:
    _txDelta = -3;
 120:	8d ef       	ldi	r24, 0xFD	; 253
 122:	86 83       	std	Z+6, r24	; 0x06
    _bitDelay = 51; break; 
 124:	83 e3       	ldi	r24, 0x33	; 51
 126:	90 e0       	ldi	r25, 0x00	; 0
 128:	00 c0       	rjmp	.+0      	; 0x12a <_ZN13NewSoftSerial5beginEl+0x12a>
  case 31250:
    _bitDelay = 62; break;
 12a:	8e e3       	ldi	r24, 0x3E	; 62
 12c:	90 e0       	ldi	r25, 0x00	; 0
 12e:	00 c0       	rjmp	.+0      	; 0x130 <_ZN13NewSoftSerial5beginEl+0x130>
  case 28800:
    _txDelta = -4;
 130:	8c ef       	ldi	r24, 0xFC	; 252
 132:	86 83       	std	Z+6, r24	; 0x06
    _bitDelay = 70; break;
 134:	86 e4       	ldi	r24, 0x46	; 70
 136:	90 e0       	ldi	r25, 0x00	; 0
 138:	00 c0       	rjmp	.+0      	; 0x13a <_ZN13NewSoftSerial5beginEl+0x13a>
  case 19200:
    _bitDelay = 108; break;
 13a:	8c e6       	ldi	r24, 0x6C	; 108
 13c:	90 e0       	ldi	r25, 0x00	; 0
 13e:	00 c0       	rjmp	.+0      	; 0x140 <_ZN13NewSoftSerial5beginEl+0x140>
  case 14400:
    _bitDelay = 152; break;
 140:	88 e9       	ldi	r24, 0x98	; 152
 142:	90 e0       	ldi	r25, 0x00	; 0
 144:	00 c0       	rjmp	.+0      	; 0x146 <_ZN13NewSoftSerial5beginEl+0x146>
  case 9600:
    _bitDelay = 226; break;
 146:	82 ee       	ldi	r24, 0xE2	; 226
 148:	90 e0       	ldi	r25, 0x00	; 0
 14a:	00 c0       	rjmp	.+0      	; 0x14c <_ZN13NewSoftSerial5beginEl+0x14c>
  case 4800:
    _bitDelay = 464; break;
 14c:	80 ed       	ldi	r24, 0xD0	; 208
 14e:	91 e0       	ldi	r25, 0x01	; 1
 150:	00 c0       	rjmp	.+0      	; 0x152 <_ZN13NewSoftSerial5beginEl+0x152>
  case 2400:
    _bitDelay = 940; break;
 152:	8c ea       	ldi	r24, 0xAC	; 172
 154:	93 e0       	ldi	r25, 0x03	; 3
 156:	00 c0       	rjmp	.+0      	; 0x158 <_ZN13NewSoftSerial5beginEl+0x158>
  case 1200:
    _bitDelay = 1868; break;
 158:	8c e4       	ldi	r24, 0x4C	; 76
 15a:	97 e0       	ldi	r25, 0x07	; 7
 15c:	00 c0       	rjmp	.+0      	; 0x15e <_ZN13NewSoftSerial5beginEl+0x15e>
  case 300:
    _bitDelay = 7436; break;
 15e:	8c e0       	ldi	r24, 0x0C	; 12
 160:	9d e1       	ldi	r25, 0x1D	; 29
 162:	00 c0       	rjmp	.+0      	; 0x164 <_ZN13NewSoftSerial5beginEl+0x164>
  default:
    _bitDelay = 0;
 164:	15 82       	std	Z+5, r1	; 0x05
 166:	14 82       	std	Z+4, r1	; 0x04
  }

  // Set up RX interrupts, but only if we have a valid RX baud rate
  if (_bitDelay && speed <= 57600)
 168:	a4 81       	ldd	r26, Z+4	; 0x04
 16a:	b5 81       	ldd	r27, Z+5	; 0x05
 16c:	10 97       	sbiw	r26, 0x00	; 0
 16e:	01 f4       	brne	.+0      	; 0x170 <_ZN13NewSoftSerial5beginEl+0x170>
 170:	00 c0       	rjmp	.+0      	; 0x172 <_ZN13NewSoftSerial5beginEl+0x172>
 172:	41 50       	subi	r20, 0x01	; 1
 174:	51 4e       	sbci	r21, 0xE1	; 225
 176:	60 40       	sbci	r22, 0x00	; 0
 178:	70 40       	sbci	r23, 0x00	; 0
 17a:	04 f0       	brlt	.+0      	; 0x17c <_ZN13NewSoftSerial5beginEl+0x17c>
 17c:	00 c0       	rjmp	.+0      	; 0x17e <_ZN13NewSoftSerial5beginEl+0x17e>
  {
    if (_receivePin < 8) {
 17e:	32 81       	ldd	r19, Z+2	; 0x02
 180:	38 30       	cpi	r19, 0x08	; 8
 182:	00 f4       	brcc	.+0      	; 0x184 <_ZN13NewSoftSerial5beginEl+0x184>
      // a PIND pin, PCINT16-23
      PCICR |= _BV(2);
 184:	80 91 68 00 	lds	r24, 0x0068
 188:	84 60       	ori	r24, 0x04	; 4
 18a:	80 93 68 00 	sts	0x0068, r24
      PCMSK2 |= _BV(_receivePin);
 18e:	20 91 6d 00 	lds	r18, 0x006D
 192:	81 e0       	ldi	r24, 0x01	; 1
 194:	90 e0       	ldi	r25, 0x00	; 0
 196:	00 c0       	rjmp	.+0      	; 0x198 <_ZN13NewSoftSerial5beginEl+0x198>
 198:	88 0f       	add	r24, r24
 19a:	99 1f       	adc	r25, r25
 19c:	3a 95       	dec	r19
 19e:	02 f4       	brpl	.+0      	; 0x1a0 <_ZN13NewSoftSerial5beginEl+0x1a0>
 1a0:	28 2b       	or	r18, r24
 1a2:	20 93 6d 00 	sts	0x006D, r18
 1a6:	00 c0       	rjmp	.+0      	; 0x1a8 <_ZN13NewSoftSerial5beginEl+0x1a8>
    } else if (_receivePin <= 13) {
 1a8:	3e 30       	cpi	r19, 0x0E	; 14
 1aa:	00 f4       	brcc	.+0      	; 0x1ac <_ZN13NewSoftSerial5beginEl+0x1ac>
      // a PINB pin, PCINT0-7
      PCICR |= _BV(0);    
 1ac:	80 91 68 00 	lds	r24, 0x0068
 1b0:	81 60       	ori	r24, 0x01	; 1
 1b2:	80 93 68 00 	sts	0x0068, r24
      PCMSK0 |= _BV(_receivePin-8);
 1b6:	40 91 6b 00 	lds	r20, 0x006B
 1ba:	23 2f       	mov	r18, r19
 1bc:	30 e0       	ldi	r19, 0x00	; 0
 1be:	28 50       	subi	r18, 0x08	; 8
 1c0:	30 40       	sbci	r19, 0x00	; 0
 1c2:	81 e0       	ldi	r24, 0x01	; 1
 1c4:	90 e0       	ldi	r25, 0x00	; 0
 1c6:	00 c0       	rjmp	.+0      	; 0x1c8 <_ZN13NewSoftSerial5beginEl+0x1c8>
 1c8:	88 0f       	add	r24, r24
 1ca:	99 1f       	adc	r25, r25
 1cc:	2a 95       	dec	r18
 1ce:	02 f4       	brpl	.+0      	; 0x1d0 <_ZN13NewSoftSerial5beginEl+0x1d0>
 1d0:	48 2b       	or	r20, r24
 1d2:	40 93 6b 00 	sts	0x006B, r20
 1d6:	00 c0       	rjmp	.+0      	; 0x1d8 <_ZN13NewSoftSerial5beginEl+0x1d8>
    } else if (_receivePin <= 21) {
 1d8:	36 31       	cpi	r19, 0x16	; 22
 1da:	00 f4       	brcc	.+0      	; 0x1dc <_ZN13NewSoftSerial5beginEl+0x1dc>
      // a PINC pin, PCINT8-14/15
      PCICR |= _BV(1);
 1dc:	80 91 68 00 	lds	r24, 0x0068
 1e0:	82 60       	ori	r24, 0x02	; 2
 1e2:	80 93 68 00 	sts	0x0068, r24
      PCMSK1 |= _BV(_receivePin-14);
 1e6:	40 91 6c 00 	lds	r20, 0x006C
 1ea:	23 2f       	mov	r18, r19
 1ec:	30 e0       	ldi	r19, 0x00	; 0
 1ee:	2e 50       	subi	r18, 0x0E	; 14
 1f0:	30 40       	sbci	r19, 0x00	; 0
 1f2:	81 e0       	ldi	r24, 0x01	; 1
 1f4:	90 e0       	ldi	r25, 0x00	; 0
 1f6:	00 c0       	rjmp	.+0      	; 0x1f8 <_ZN13NewSoftSerial5beginEl+0x1f8>
 1f8:	88 0f       	add	r24, r24
 1fa:	99 1f       	adc	r25, r25
 1fc:	2a 95       	dec	r18
 1fe:	02 f4       	brpl	.+0      	; 0x200 <_ZN13NewSoftSerial5beginEl+0x200>
 200:	48 2b       	or	r20, r24
 202:	40 93 6c 00 	sts	0x006C, r20
    } 

#if (F_CPU == 8000000)
    if (_bitDelay)
      _bitDelay = _bitDelay / 2 + 6;
 206:	cd 01       	movw	r24, r26
 208:	96 95       	lsr	r25
 20a:	87 95       	ror	r24
 20c:	06 96       	adiw	r24, 0x06	; 6
 20e:	95 83       	std	Z+5, r25	; 0x05
 210:	84 83       	std	Z+4, r24	; 0x04
    "cpi %A0, 0xFF \n\t"
    "cpc %B0, %1 \n\t"
    "brne .-10 \n\t"
    : "+r" (delay), "+a" (tmp)
    : "0" (delay)
    );
 212:	20 e0       	ldi	r18, 0x00	; 0
 214:	01 97       	sbiw	r24, 0x01	; 1
 216:	2f ef       	ldi	r18, 0xFF	; 255
 218:	8f 3f       	cpi	r24, 0xFF	; 255
 21a:	92 07       	cpc	r25, r18
 21c:	01 f4       	brne	.+0      	; 0x21e <_ZN13NewSoftSerial5beginEl+0x21e>

// This function sets the current object as the "active"
// one and returns true if it replaces another 
bool NewSoftSerial::activate(void)
{
  if (active_object != this)
 21e:	80 91 00 00 	lds	r24, 0x0000
 222:	90 91 00 00 	lds	r25, 0x0000
 226:	8e 17       	cp	r24, r30
 228:	9f 07       	cpc	r25, r31
 22a:	01 f0       	breq	.+0      	; 0x22c <_ZN13NewSoftSerial5beginEl+0x22c>
  {
    _buffer_overflow = false;
 22c:	17 82       	std	Z+7, r1	; 0x07
    uint8_t oldSREG = SREG;
 22e:	9f b7       	in	r25, 0x3f	; 63
    cli();
 230:	f8 94       	cli
    _receive_buffer_head = _receive_buffer_tail = 0;
 232:	10 92 00 00 	sts	0x0000, r1
 236:	80 91 00 00 	lds	r24, 0x0000
 23a:	80 93 00 00 	sts	0x0000, r24
    active_object = this;
 23e:	f0 93 00 00 	sts	0x0000, r31
 242:	e0 93 00 00 	sts	0x0000, r30
    SREG = oldSREG;
 246:	9f bf       	out	0x3f, r25	; 63
 248:	08 95       	ret
Disassembly of section .text._ZN13NewSoftSerial4readEv:

00000000 <_ZN13NewSoftSerial4readEv>:

  activate();
}

// Read data from buffer
int NewSoftSerial::read(void)
   0:	fc 01       	movw	r30, r24

// This function sets the current object as the "active"
// one and returns true if it replaces another 
bool NewSoftSerial::activate(void)
{
  if (active_object != this)
   2:	80 91 00 00 	lds	r24, 0x0000
   6:	90 91 00 00 	lds	r25, 0x0000
   a:	8e 17       	cp	r24, r30
   c:	9f 07       	cpc	r25, r31
   e:	01 f0       	breq	.+0      	; 0x10 <_ZN13NewSoftSerial4readEv+0x10>
  {
    _buffer_overflow = false;
  10:	17 82       	std	Z+7, r1	; 0x07
    uint8_t oldSREG = SREG;
  12:	9f b7       	in	r25, 0x3f	; 63
    cli();
  14:	f8 94       	cli
    _receive_buffer_head = _receive_buffer_tail = 0;
  16:	10 92 00 00 	sts	0x0000, r1
  1a:	80 91 00 00 	lds	r24, 0x0000
  1e:	80 93 00 00 	sts	0x0000, r24
    active_object = this;
  22:	f0 93 00 00 	sts	0x0000, r31
  26:	e0 93 00 00 	sts	0x0000, r30
    SREG = oldSREG;
  2a:	9f bf       	out	0x3f, r25	; 63
  2c:	00 c0       	rjmp	.+0      	; 0x2e <_ZN13NewSoftSerial4readEv+0x2e>
  // A newly activated object never has any rx data
  if (activate())
    return -1;

  // Empty buffer?
  if (_receive_buffer_head == _receive_buffer_tail)
  2e:	90 91 00 00 	lds	r25, 0x0000
  32:	80 91 00 00 	lds	r24, 0x0000
  36:	98 17       	cp	r25, r24
  38:	01 f4       	brne	.+0      	; 0x3a <_ZN13NewSoftSerial4readEv+0x3a>
  3a:	2f ef       	ldi	r18, 0xFF	; 255
  3c:	3f ef       	ldi	r19, 0xFF	; 255
  3e:	00 c0       	rjmp	.+0      	; 0x40 <_ZN13NewSoftSerial4readEv+0x40>
    return -1;

  // Read from "head"
  d = _receive_buffer[_receive_buffer_head]; // grab next byte
  40:	e0 91 00 00 	lds	r30, 0x0000
  44:	f0 e0       	ldi	r31, 0x00	; 0
  46:	e0 50       	subi	r30, 0x00	; 0
  48:	f0 40       	sbci	r31, 0x00	; 0
  4a:	20 81       	ld	r18, Z
  _receive_buffer_head = (_receive_buffer_head + 1) % _NewSS_MAX_RX_BUFF;
  4c:	80 91 00 00 	lds	r24, 0x0000
  50:	90 e0       	ldi	r25, 0x00	; 0
  52:	01 96       	adiw	r24, 0x01	; 1
  54:	8f 73       	andi	r24, 0x3F	; 63
  56:	90 70       	andi	r25, 0x00	; 0
  58:	80 93 00 00 	sts	0x0000, r24
  return d;
  5c:	30 e0       	ldi	r19, 0x00	; 0
}
  5e:	c9 01       	movw	r24, r18
  60:	08 95       	ret
Disassembly of section .text._ZN13NewSoftSerial9availableEv:

00000000 <_ZN13NewSoftSerial9availableEv>:

uint8_t NewSoftSerial::available(void)
   0:	fc 01       	movw	r30, r24

// This function sets the current object as the "active"
// one and returns true if it replaces another 
bool NewSoftSerial::activate(void)
{
  if (active_object != this)
   2:	80 91 00 00 	lds	r24, 0x0000
   6:	90 91 00 00 	lds	r25, 0x0000
   a:	8e 17       	cp	r24, r30
   c:	9f 07       	cpc	r25, r31
   e:	01 f0       	breq	.+0      	; 0x10 <_ZN13NewSoftSerial9availableEv+0x10>
  {
    _buffer_overflow = false;
  10:	17 82       	std	Z+7, r1	; 0x07
    uint8_t oldSREG = SREG;
  12:	9f b7       	in	r25, 0x3f	; 63
    cli();
  14:	f8 94       	cli
    _receive_buffer_head = _receive_buffer_tail = 0;
  16:	10 92 00 00 	sts	0x0000, r1
  1a:	80 91 00 00 	lds	r24, 0x0000
  1e:	80 93 00 00 	sts	0x0000, r24
    active_object = this;
  22:	f0 93 00 00 	sts	0x0000, r31
  26:	e0 93 00 00 	sts	0x0000, r30
    SREG = oldSREG;
  2a:	9f bf       	out	0x3f, r25	; 63
  2c:	80 e0       	ldi	r24, 0x00	; 0
  2e:	08 95       	ret
{
  // A newly activated object never has any rx data
  if (activate())
    return 0;

  return (_receive_buffer_tail + _NewSS_MAX_RX_BUFF - _receive_buffer_head) % _NewSS_MAX_RX_BUFF;
  30:	80 91 00 00 	lds	r24, 0x0000
  34:	20 91 00 00 	lds	r18, 0x0000
  38:	90 e0       	ldi	r25, 0x00	; 0
  3a:	80 5c       	subi	r24, 0xC0	; 192
  3c:	9f 4f       	sbci	r25, 0xFF	; 255
  3e:	82 1b       	sub	r24, r18
  40:	91 09       	sbc	r25, r1
  42:	60 e4       	ldi	r22, 0x40	; 64
  44:	70 e0       	ldi	r23, 0x00	; 0
  46:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerial9availableEv>
}
  4a:	08 95       	ret
Disassembly of section .text._ZN13NewSoftSerial5writeEh:

00000000 <_ZN13NewSoftSerial5writeEh>:

void NewSoftSerial::write(uint8_t b)
   0:	bf 92       	push	r11
   2:	cf 92       	push	r12
   4:	df 92       	push	r13
   6:	ef 92       	push	r14
   8:	ff 92       	push	r15
   a:	0f 93       	push	r16
   c:	1f 93       	push	r17
   e:	cf 93       	push	r28
  10:	df 93       	push	r29
  12:	ec 01       	movw	r28, r24
  14:	e6 2e       	mov	r14, r22
{
  if (_bitDelay == 0)
  16:	8c 81       	ldd	r24, Y+4	; 0x04
  18:	9d 81       	ldd	r25, Y+5	; 0x05
  1a:	89 2b       	or	r24, r25
  1c:	01 f4       	brne	.+0      	; 0x1e <_ZN13NewSoftSerial5writeEh+0x1e>
  1e:	00 c0       	rjmp	.+0      	; 0x20 <_ZN13NewSoftSerial5writeEh+0x20>

// This function sets the current object as the "active"
// one and returns true if it replaces another 
bool NewSoftSerial::activate(void)
{
  if (active_object != this)
  20:	80 91 00 00 	lds	r24, 0x0000
  24:	90 91 00 00 	lds	r25, 0x0000
  28:	8c 17       	cp	r24, r28
  2a:	9d 07       	cpc	r25, r29
  2c:	01 f0       	breq	.+0      	; 0x2e <_ZN13NewSoftSerial5writeEh+0x2e>
  {
    _buffer_overflow = false;
  2e:	1f 82       	std	Y+7, r1	; 0x07
    uint8_t oldSREG = SREG;
  30:	9f b7       	in	r25, 0x3f	; 63
    cli();
  32:	f8 94       	cli
    _receive_buffer_head = _receive_buffer_tail = 0;
  34:	10 92 00 00 	sts	0x0000, r1
  38:	80 91 00 00 	lds	r24, 0x0000
  3c:	80 93 00 00 	sts	0x0000, r24
    active_object = this;
  40:	d0 93 00 00 	sts	0x0000, r29
  44:	c0 93 00 00 	sts	0x0000, r28
    SREG = oldSREG;
  48:	9f bf       	out	0x3f, r25	; 63
  if (_bitDelay == 0)
    return;

  activate();

  uint8_t oldSREG = SREG;
  4a:	bf b6       	in	r11, 0x3f	; 63
  cli();  // turn off interrupts for a clean txmit
  4c:	f8 94       	cli

  // Write the start bit
  digitalWrite(_transmitPin, LOW);
  4e:	60 e0       	ldi	r22, 0x00	; 0
  50:	8b 81       	ldd	r24, Y+3	; 0x03
  52:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerial5writeEh>
  tunedDelay(_bitDelay + _txDelta);
  56:	8e 81       	ldd	r24, Y+6	; 0x06
  58:	99 27       	eor	r25, r25
  5a:	87 fd       	sbrc	r24, 7
  5c:	90 95       	com	r25
  5e:	2c 81       	ldd	r18, Y+4	; 0x04
  60:	3d 81       	ldd	r19, Y+5	; 0x05
  62:	82 0f       	add	r24, r18
  64:	93 1f       	adc	r25, r19
    "cpi %A0, 0xFF \n\t"
    "cpc %B0, %1 \n\t"
    "brne .-10 \n\t"
    : "+r" (delay), "+a" (tmp)
    : "0" (delay)
    );
  66:	20 e0       	ldi	r18, 0x00	; 0
  68:	01 97       	sbiw	r24, 0x01	; 1
  6a:	2f ef       	ldi	r18, 0xFF	; 255
  6c:	8f 3f       	cpi	r24, 0xFF	; 255
  6e:	92 07       	cpc	r25, r18
  70:	01 f4       	brne	.+0      	; 0x72 <_ZN13NewSoftSerial5writeEh+0x72>
  72:	ff 24       	eor	r15, r15
  74:	f3 94       	inc	r15
  76:	08 e0       	ldi	r16, 0x08	; 8
  78:	10 e0       	ldi	r17, 0x00	; 0
  digitalWrite(_transmitPin, LOW);
  tunedDelay(_bitDelay + _txDelta);

  // Write each of the 8 bits
  for (byte mask = 0x01; mask; mask <<= 1) {
    if (b & mask){ // choose bit
  7a:	ce 2c       	mov	r12, r14
  7c:	dd 24       	eor	r13, r13
  7e:	8f 2d       	mov	r24, r15
  80:	90 e0       	ldi	r25, 0x00	; 0
  82:	8c 21       	and	r24, r12
  84:	9d 21       	and	r25, r13
  86:	89 2b       	or	r24, r25
  88:	01 f0       	breq	.+0      	; 0x8a <_ZN13NewSoftSerial5writeEh+0x8a>
      digitalWrite(_transmitPin, HIGH); // send 1
  8a:	61 e0       	ldi	r22, 0x01	; 1
  8c:	00 c0       	rjmp	.+0      	; 0x8e <_ZN13NewSoftSerial5writeEh+0x8e>
    }
    else{
      digitalWrite(_transmitPin, LOW); // send 0
  8e:	60 e0       	ldi	r22, 0x00	; 0
  90:	8b 81       	ldd	r24, Y+3	; 0x03
  92:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerial5writeEh>
    }
    tunedDelay(_bitDelay + _txDelta);
  96:	8e 81       	ldd	r24, Y+6	; 0x06
  98:	99 27       	eor	r25, r25
  9a:	87 fd       	sbrc	r24, 7
  9c:	90 95       	com	r25
  9e:	2c 81       	ldd	r18, Y+4	; 0x04
  a0:	3d 81       	ldd	r19, Y+5	; 0x05
  a2:	82 0f       	add	r24, r18
  a4:	93 1f       	adc	r25, r19
    "cpi %A0, 0xFF \n\t"
    "cpc %B0, %1 \n\t"
    "brne .-10 \n\t"
    : "+r" (delay), "+a" (tmp)
    : "0" (delay)
    );
  a6:	ee 24       	eor	r14, r14
  a8:	2e 2d       	mov	r18, r14
  aa:	01 97       	sbiw	r24, 0x01	; 1
  ac:	2f ef       	ldi	r18, 0xFF	; 255
  ae:	8f 3f       	cpi	r24, 0xFF	; 255
  b0:	92 07       	cpc	r25, r18
  b2:	01 f4       	brne	.+0      	; 0xb4 <_ZN13NewSoftSerial5writeEh+0xb4>
  // Write the start bit
  digitalWrite(_transmitPin, LOW);
  tunedDelay(_bitDelay + _txDelta);

  // Write each of the 8 bits
  for (byte mask = 0x01; mask; mask <<= 1) {
  b4:	ff 0c       	add	r15, r15
  b6:	01 50       	subi	r16, 0x01	; 1
  b8:	10 40       	sbci	r17, 0x00	; 0
  ba:	01 f4       	brne	.+0      	; 0xbc <_ZN13NewSoftSerial5writeEh+0xbc>
      digitalWrite(_transmitPin, LOW); // send 0
    }
    tunedDelay(_bitDelay + _txDelta);
  }

  digitalWrite(_transmitPin, HIGH);
  bc:	61 e0       	ldi	r22, 0x01	; 1
  be:	8b 81       	ldd	r24, Y+3	; 0x03
  c0:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerial5writeEh>
  SREG = oldSREG; // turn interrupts back on. hooray!
  c4:	bf be       	out	0x3f, r11	; 63
  tunedDelay(_bitDelay + _txDelta);
  c6:	8e 81       	ldd	r24, Y+6	; 0x06
  c8:	99 27       	eor	r25, r25
  ca:	87 fd       	sbrc	r24, 7
  cc:	90 95       	com	r25
  ce:	2c 81       	ldd	r18, Y+4	; 0x04
  d0:	3d 81       	ldd	r19, Y+5	; 0x05
  d2:	82 0f       	add	r24, r18
  d4:	93 1f       	adc	r25, r19
    "cpi %A0, 0xFF \n\t"
    "cpc %B0, %1 \n\t"
    "brne .-10 \n\t"
    : "+r" (delay), "+a" (tmp)
    : "0" (delay)
    );
  d6:	2e 2d       	mov	r18, r14
  d8:	01 97       	sbiw	r24, 0x01	; 1
  da:	2f ef       	ldi	r18, 0xFF	; 255
  dc:	8f 3f       	cpi	r24, 0xFF	; 255
  de:	92 07       	cpc	r25, r18
  e0:	01 f4       	brne	.+0      	; 0xe2 <_ZN13NewSoftSerial5writeEh+0xe2>
  }

  digitalWrite(_transmitPin, HIGH);
  SREG = oldSREG; // turn interrupts back on. hooray!
  tunedDelay(_bitDelay + _txDelta);
}
  e2:	df 91       	pop	r29
  e4:	cf 91       	pop	r28
  e6:	1f 91       	pop	r17
  e8:	0f 91       	pop	r16
  ea:	ff 90       	pop	r15
  ec:	ef 90       	pop	r14
  ee:	df 90       	pop	r13
  f0:	cf 90       	pop	r12
  f2:	bf 90       	pop	r11
  f4:	08 95       	ret
Disassembly of section .text._ZN13NewSoftSerial5setRXEh:

00000000 <_ZN13NewSoftSerial5setRXEh>:
  _transmitPin = tx;
  pinMode(_transmitPin, OUTPUT);
  digitalWrite(_transmitPin, HIGH);
}

void NewSoftSerial::setRX(uint8_t rx)
   0:	0f 93       	push	r16
   2:	1f 93       	push	r17
   4:	8c 01       	movw	r16, r24
   6:	86 2f       	mov	r24, r22
{
  _receivePin = rx;
   8:	f8 01       	movw	r30, r16
   a:	62 83       	std	Z+2, r22	; 0x02
  pinMode(_receivePin, INPUT); 
   c:	60 e0       	ldi	r22, 0x00	; 0
   e:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerial5setRXEh>
  digitalWrite(_receivePin, HIGH);  // pullup!
  12:	61 e0       	ldi	r22, 0x01	; 1
  14:	f8 01       	movw	r30, r16
  16:	82 81       	ldd	r24, Z+2	; 0x02
  18:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerial5setRXEh>
}
  1c:	1f 91       	pop	r17
  1e:	0f 91       	pop	r16
  20:	08 95       	ret
Disassembly of section .text._ZN13NewSoftSerial5setTXEh:

00000000 <_ZN13NewSoftSerial5setTXEh>:
}

/******************************************************************************
* Public methods
******************************************************************************/
void NewSoftSerial::setTX(uint8_t tx)
   0:	0f 93       	push	r16
   2:	1f 93       	push	r17
   4:	8c 01       	movw	r16, r24
   6:	86 2f       	mov	r24, r22
{
  _transmitPin = tx;
   8:	f8 01       	movw	r30, r16
   a:	63 83       	std	Z+3, r22	; 0x03
  pinMode(_transmitPin, OUTPUT);
   c:	61 e0       	ldi	r22, 0x01	; 1
   e:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerial5setTXEh>
  digitalWrite(_transmitPin, HIGH);
  12:	61 e0       	ldi	r22, 0x01	; 1
  14:	f8 01       	movw	r30, r16
  16:	83 81       	ldd	r24, Z+3	; 0x03
  18:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerial5setTXEh>
}
  1c:	1f 91       	pop	r17
  1e:	0f 91       	pop	r16
  20:	08 95       	ret
Disassembly of section .text._ZN13NewSoftSerialC1Ehh:

00000000 <_ZN13NewSoftSerialC1Ehh>:
}

/******************************************************************************
* Constructor
******************************************************************************/
NewSoftSerial::NewSoftSerial(uint8_t receivePin, uint8_t transmitPin) : 
   0:	ff 92       	push	r15
   2:	0f 93       	push	r16
   4:	1f 93       	push	r17
   6:	8c 01       	movw	r16, r24
   8:	f6 2e       	mov	r15, r22
  _bitDelay(0),
  _txDelta(0),
  _buffer_overflow(false)
   a:	80 e0       	ldi	r24, 0x00	; 0
   c:	90 e0       	ldi	r25, 0x00	; 0
   e:	f8 01       	movw	r30, r16
  10:	91 83       	std	Z+1, r25	; 0x01
  12:	80 83       	st	Z, r24
  14:	15 82       	std	Z+5, r1	; 0x05
  16:	14 82       	std	Z+4, r1	; 0x04
  18:	16 82       	std	Z+6, r1	; 0x06
  1a:	17 82       	std	Z+7, r1	; 0x07
{
  setTX(transmitPin);
  1c:	64 2f       	mov	r22, r20
  1e:	c8 01       	movw	r24, r16
  20:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerialC1Ehh>
  setRX(receivePin);
  24:	6f 2d       	mov	r22, r15
  26:	c8 01       	movw	r24, r16
  28:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerialC1Ehh>
}
  2c:	1f 91       	pop	r17
  2e:	0f 91       	pop	r16
  30:	ff 90       	pop	r15
  32:	08 95       	ret
Disassembly of section .text._ZN13NewSoftSerialC2Ehh:

00000000 <_ZN13NewSoftSerialC2Ehh>:
}

/******************************************************************************
* Constructor
******************************************************************************/
NewSoftSerial::NewSoftSerial(uint8_t receivePin, uint8_t transmitPin) : 
   0:	ff 92       	push	r15
   2:	0f 93       	push	r16
   4:	1f 93       	push	r17
   6:	8c 01       	movw	r16, r24
   8:	f6 2e       	mov	r15, r22
  _bitDelay(0),
  _txDelta(0),
  _buffer_overflow(false)
   a:	80 e0       	ldi	r24, 0x00	; 0
   c:	90 e0       	ldi	r25, 0x00	; 0
   e:	f8 01       	movw	r30, r16
  10:	91 83       	std	Z+1, r25	; 0x01
  12:	80 83       	st	Z, r24
  14:	15 82       	std	Z+5, r1	; 0x05
  16:	14 82       	std	Z+4, r1	; 0x04
  18:	16 82       	std	Z+6, r1	; 0x06
  1a:	17 82       	std	Z+7, r1	; 0x07
{
  setTX(transmitPin);
  1c:	64 2f       	mov	r22, r20
  1e:	c8 01       	movw	r24, r16
  20:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerialC2Ehh>
  setRX(receivePin);
  24:	6f 2d       	mov	r22, r15
  26:	c8 01       	movw	r24, r16
  28:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerialC2Ehh>
}
  2c:	1f 91       	pop	r17
  2e:	0f 91       	pop	r16
  30:	ff 90       	pop	r15
  32:	08 95       	ret
Disassembly of section .text._ZN13NewSoftSerial4recvEv:

00000000 <_ZN13NewSoftSerial4recvEv>:

  return false;
}

// The receive routine called by the interrupt handler
void NewSoftSerial::recv() 
   0:	cf 92       	push	r12
   2:	df 92       	push	r13
   4:	ef 92       	push	r14
   6:	ff 92       	push	r15
   8:	0f 93       	push	r16
   a:	1f 93       	push	r17
   c:	cf 93       	push	r28
   e:	df 93       	push	r29
  10:	8c 01       	movw	r16, r24
{
  char i, d = 0; 

  // If RX line is high, then we don't see any start bit
  // so interrupt is probably not for us
  if (digitalRead(_receivePin)) 
  12:	fc 01       	movw	r30, r24
  14:	82 81       	ldd	r24, Z+2	; 0x02
  16:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerial4recvEv>
  1a:	89 2b       	or	r24, r25
  1c:	01 f0       	breq	.+0      	; 0x1e <_ZN13NewSoftSerial4recvEv+0x1e>
  1e:	00 c0       	rjmp	.+0      	; 0x20 <_ZN13NewSoftSerial4recvEv+0x20>
    return;

  // Wait approximately 1/2 of a bit width to "center" the sample
  tunedDelay(_bitDelay / 2 - 8);
  20:	f8 01       	movw	r30, r16
  22:	84 81       	ldd	r24, Z+4	; 0x04
  24:	95 81       	ldd	r25, Z+5	; 0x05
  26:	96 95       	lsr	r25
  28:	87 95       	ror	r24
  2a:	08 97       	sbiw	r24, 0x08	; 8
    "cpi %A0, 0xFF \n\t"
    "cpc %B0, %1 \n\t"
    "brne .-10 \n\t"
    : "+r" (delay), "+a" (tmp)
    : "0" (delay)
    );
  2c:	20 e0       	ldi	r18, 0x00	; 0
  2e:	01 97       	sbiw	r24, 0x01	; 1
  30:	2f ef       	ldi	r18, 0xFF	; 255
  32:	8f 3f       	cpi	r24, 0xFF	; 255
  34:	92 07       	cpc	r25, r18
  36:	01 f4       	brne	.+0      	; 0x38 <_ZN13NewSoftSerial4recvEv+0x38>
  38:	ff 24       	eor	r15, r15
  3a:	c0 e0       	ldi	r28, 0x00	; 0
  3c:	d0 e0       	ldi	r29, 0x00	; 0
    tunedDelay(_bitDelay - 6);  // 6 - digitalread takes some time
    //PORTB &= ~_BV(5);
    if (digitalRead(_receivePin))
      d |= (1 << i); 
    else // else clause added to ensure function timing is ~balanced
      d &= ~(1 << i);
  3e:	ee 24       	eor	r14, r14
  40:	31 e0       	ldi	r19, 0x01	; 1
  42:	c3 2e       	mov	r12, r19
  44:	d1 2c       	mov	r13, r1
  tunedDelay(_bitDelay / 2 - 8);

  // Read each of the 8 bits
  for (i=0; i<8; i++) { 
    //PORTB |= _BV(5);
    tunedDelay(_bitDelay - 6);  // 6 - digitalread takes some time
  46:	f8 01       	movw	r30, r16
  48:	84 81       	ldd	r24, Z+4	; 0x04
  4a:	95 81       	ldd	r25, Z+5	; 0x05
  4c:	06 97       	sbiw	r24, 0x06	; 6
    "cpi %A0, 0xFF \n\t"
    "cpc %B0, %1 \n\t"
    "brne .-10 \n\t"
    : "+r" (delay), "+a" (tmp)
    : "0" (delay)
    );
  4e:	2e 2d       	mov	r18, r14
  50:	01 97       	sbiw	r24, 0x01	; 1
  52:	2f ef       	ldi	r18, 0xFF	; 255
  54:	8f 3f       	cpi	r24, 0xFF	; 255
  56:	92 07       	cpc	r25, r18
  58:	01 f4       	brne	.+0      	; 0x5a <_ZN13NewSoftSerial4recvEv+0x5a>
  // Read each of the 8 bits
  for (i=0; i<8; i++) { 
    //PORTB |= _BV(5);
    tunedDelay(_bitDelay - 6);  // 6 - digitalread takes some time
    //PORTB &= ~_BV(5);
    if (digitalRead(_receivePin))
  5a:	82 81       	ldd	r24, Z+2	; 0x02
  5c:	0e 94 00 00 	call	0	; 0x0 <_ZN13NewSoftSerial4recvEv>
  60:	89 2b       	or	r24, r25
  62:	01 f0       	breq	.+0      	; 0x64 <_ZN13NewSoftSerial4recvEv+0x64>
      d |= (1 << i); 
  64:	c6 01       	movw	r24, r12
  66:	0c 2e       	mov	r0, r28
  68:	00 c0       	rjmp	.+0      	; 0x6a <_ZN13NewSoftSerial4recvEv+0x6a>
  6a:	88 0f       	add	r24, r24
  6c:	99 1f       	adc	r25, r25
  6e:	0a 94       	dec	r0
  70:	02 f4       	brpl	.+0      	; 0x72 <_ZN13NewSoftSerial4recvEv+0x72>
  72:	f8 2a       	or	r15, r24
  74:	00 c0       	rjmp	.+0      	; 0x76 <_ZN13NewSoftSerial4recvEv+0x76>
    else // else clause added to ensure function timing is ~balanced
      d &= ~(1 << i);
  76:	c6 01       	movw	r24, r12
  78:	0c 2e       	mov	r0, r28
  7a:	00 c0       	rjmp	.+0      	; 0x7c <_ZN13NewSoftSerial4recvEv+0x7c>
  7c:	88 0f       	add	r24, r24
  7e:	99 1f       	adc	r25, r25
  80:	0a 94       	dec	r0
  82:	02 f4       	brpl	.+0      	; 0x84 <_ZN13NewSoftSerial4recvEv+0x84>
  84:	80 95       	com	r24
  86:	f8 22       	and	r15, r24
  88:	21 96       	adiw	r28, 0x01	; 1

  // Wait approximately 1/2 of a bit width to "center" the sample
  tunedDelay(_bitDelay / 2 - 8);

  // Read each of the 8 bits
  for (i=0; i<8; i++) { 
  8a:	c8 30       	cpi	r28, 0x08	; 8
  8c:	d1 05       	cpc	r29, r1
  8e:	01 f4       	brne	.+0      	; 0x90 <_ZN13NewSoftSerial4recvEv+0x90>
    else // else clause added to ensure function timing is ~balanced
      d &= ~(1 << i);
  } 

  // skip the stop bit
  tunedDelay(_bitDelay);
  90:	f8 01       	movw	r30, r16
  92:	84 81       	ldd	r24, Z+4	; 0x04
  94:	95 81       	ldd	r25, Z+5	; 0x05
    "cpi %A0, 0xFF \n\t"
    "cpc %B0, %1 \n\t"
    "brne .-10 \n\t"
    : "+r" (delay), "+a" (tmp)
    : "0" (delay)
    );
  96:	20 e0       	ldi	r18, 0x00	; 0
  98:	01 97       	sbiw	r24, 0x01	; 1
  9a:	2f ef       	ldi	r18, 0xFF	; 255
  9c:	8f 3f       	cpi	r24, 0xFF	; 255
  9e:	92 07       	cpc	r25, r18
  a0:	01 f4       	brne	.+0      	; 0xa2 <_ZN13NewSoftSerial4recvEv+0xa2>

  // skip the stop bit
  tunedDelay(_bitDelay);

  // if buffer full, set the overflow flag and return
  if ((_receive_buffer_tail + 1) % _NewSS_MAX_RX_BUFF == _receive_buffer_head)
  a2:	80 91 00 00 	lds	r24, 0x0000
  a6:	20 91 00 00 	lds	r18, 0x0000
  aa:	90 e0       	ldi	r25, 0x00	; 0
  ac:	01 96       	adiw	r24, 0x01	; 1
  ae:	8f 73       	andi	r24, 0x3F	; 63
  b0:	90 70       	andi	r25, 0x00	; 0
  b2:	30 e0       	ldi	r19, 0x00	; 0
  b4:	82 17       	cp	r24, r18
  b6:	93 07       	cpc	r25, r19
  b8:	01 f4       	brne	.+0      	; 0xba <_ZN13NewSoftSerial4recvEv+0xba>
  {
    _buffer_overflow = true;
  ba:	81 e0       	ldi	r24, 0x01	; 1
  bc:	87 83       	std	Z+7, r24	; 0x07
  be:	00 c0       	rjmp	.+0      	; 0xc0 <_ZN13NewSoftSerial4recvEv+0xc0>
    return;
  }

  // save new data in buffer: tail points to where byte goes
  _receive_buffer[_receive_buffer_tail] = d; // save new byte 
  c0:	e0 91 00 00 	lds	r30, 0x0000
  c4:	f0 e0       	ldi	r31, 0x00	; 0
  c6:	e0 50       	subi	r30, 0x00	; 0
  c8:	f0 40       	sbci	r31, 0x00	; 0
  ca:	f0 82       	st	Z, r15
  _receive_buffer_tail = (_receive_buffer_tail + 1) % _NewSS_MAX_RX_BUFF;
  cc:	80 91 00 00 	lds	r24, 0x0000
  d0:	90 e0       	ldi	r25, 0x00	; 0
  d2:	01 96       	adiw	r24, 0x01	; 1
  d4:	8f 73       	andi	r24, 0x3F	; 63
  d6:	90 70       	andi	r25, 0x00	; 0
  d8:	80 93 00 00 	sts	0x0000, r24
} 
  dc:	df 91       	pop	r29
  de:	cf 91       	pop	r28
  e0:	1f 91       	pop	r17
  e2:	0f 91       	pop	r16
  e4:	ff 90       	pop	r15
  e6:	ef 90       	pop	r14
  e8:	df 90       	pop	r13
  ea:	cf 90       	pop	r12
  ec:	08 95       	ret
Disassembly of section .text.__vector_5:

00000000 <__vector_5>:
SIGNAL(SIG_PIN_CHANGE1) 
{
  NewSoftSerial::handle_interrupts(14, 21);
}

SIGNAL(SIG_PIN_CHANGE2)
   0:	1f 92       	push	r1
   2:	0f 92       	push	r0
   4:	0f b6       	in	r0, 0x3f	; 63
   6:	0f 92       	push	r0
   8:	11 24       	eor	r1, r1
   a:	2f 93       	push	r18
   c:	3f 93       	push	r19
   e:	4f 93       	push	r20
  10:	5f 93       	push	r21
  12:	6f 93       	push	r22
  14:	7f 93       	push	r23
  16:	8f 93       	push	r24
  18:	9f 93       	push	r25
  1a:	af 93       	push	r26
  1c:	bf 93       	push	r27
  1e:	ef 93       	push	r30
  20:	ff 93       	push	r31
******************************************************************************/

/* static */
inline void NewSoftSerial::handle_interrupts(int lopin, int hipin)
{
  if (active_object && 
  22:	e0 91 00 00 	lds	r30, 0x0000
  26:	f0 91 00 00 	lds	r31, 0x0000
  2a:	30 97       	sbiw	r30, 0x00	; 0
  2c:	01 f0       	breq	.+0      	; 0x2e <__vector_5+0x2e>
  2e:	82 81       	ldd	r24, Z+2	; 0x02
  30:	90 e0       	ldi	r25, 0x00	; 0
  32:	08 97       	sbiw	r24, 0x08	; 8
  34:	04 f4       	brge	.+0      	; 0x36 <__vector_5+0x36>
    active_object->_receivePin >= lopin && 
    active_object->_receivePin <= hipin)
  {
    active_object->recv();
  36:	cf 01       	movw	r24, r30
  38:	0e 94 00 00 	call	0	; 0x0 <__vector_5>
}

SIGNAL(SIG_PIN_CHANGE2)
{
  NewSoftSerial::handle_interrupts(0, 7);
}
  3c:	ff 91       	pop	r31
  3e:	ef 91       	pop	r30
  40:	bf 91       	pop	r27
  42:	af 91       	pop	r26
  44:	9f 91       	pop	r25
  46:	8f 91       	pop	r24
  48:	7f 91       	pop	r23
  4a:	6f 91       	pop	r22
  4c:	5f 91       	pop	r21
  4e:	4f 91       	pop	r20
  50:	3f 91       	pop	r19
  52:	2f 91       	pop	r18
  54:	0f 90       	pop	r0
  56:	0f be       	out	0x3f, r0	; 63
  58:	0f 90       	pop	r0
  5a:	1f 90       	pop	r1
  5c:	18 95       	reti
Disassembly of section .text.__vector_4:

00000000 <__vector_4>:
SIGNAL(SIG_PIN_CHANGE0) 
{
  NewSoftSerial::handle_interrupts(8, 13);
}

SIGNAL(SIG_PIN_CHANGE1) 
   0:	1f 92       	push	r1
   2:	0f 92       	push	r0
   4:	0f b6       	in	r0, 0x3f	; 63
   6:	0f 92       	push	r0
   8:	11 24       	eor	r1, r1
   a:	2f 93       	push	r18
   c:	3f 93       	push	r19
   e:	4f 93       	push	r20
  10:	5f 93       	push	r21
  12:	6f 93       	push	r22
  14:	7f 93       	push	r23
  16:	8f 93       	push	r24
  18:	9f 93       	push	r25
  1a:	af 93       	push	r26
  1c:	bf 93       	push	r27
  1e:	ef 93       	push	r30
  20:	ff 93       	push	r31
******************************************************************************/

/* static */
inline void NewSoftSerial::handle_interrupts(int lopin, int hipin)
{
  if (active_object && 
  22:	e0 91 00 00 	lds	r30, 0x0000
  26:	f0 91 00 00 	lds	r31, 0x0000
  2a:	30 97       	sbiw	r30, 0x00	; 0
  2c:	01 f0       	breq	.+0      	; 0x2e <__vector_4+0x2e>
  2e:	82 81       	ldd	r24, Z+2	; 0x02
  30:	90 e0       	ldi	r25, 0x00	; 0
  32:	8e 30       	cpi	r24, 0x0E	; 14
  34:	91 05       	cpc	r25, r1
  36:	04 f0       	brlt	.+0      	; 0x38 <__vector_4+0x38>
  38:	46 97       	sbiw	r24, 0x16	; 22
  3a:	04 f4       	brge	.+0      	; 0x3c <__vector_4+0x3c>
    active_object->_receivePin >= lopin && 
    active_object->_receivePin <= hipin)
  {
    active_object->recv();
  3c:	cf 01       	movw	r24, r30
  3e:	0e 94 00 00 	call	0	; 0x0 <__vector_4>
}

SIGNAL(SIG_PIN_CHANGE1) 
{
  NewSoftSerial::handle_interrupts(14, 21);
}
  42:	ff 91       	pop	r31
  44:	ef 91       	pop	r30
  46:	bf 91       	pop	r27
  48:	af 91       	pop	r26
  4a:	9f 91       	pop	r25
  4c:	8f 91       	pop	r24
  4e:	7f 91       	pop	r23
  50:	6f 91       	pop	r22
  52:	5f 91       	pop	r21
  54:	4f 91       	pop	r20
  56:	3f 91       	pop	r19
  58:	2f 91       	pop	r18
  5a:	0f 90       	pop	r0
  5c:	0f be       	out	0x3f, r0	; 63
  5e:	0f 90       	pop	r0
  60:	1f 90       	pop	r1
  62:	18 95       	reti
Disassembly of section .text.__vector_3:

00000000 <__vector_3>:
  {
    active_object->recv();
  }
}

SIGNAL(SIG_PIN_CHANGE0) 
   0:	1f 92       	push	r1
   2:	0f 92       	push	r0
   4:	0f b6       	in	r0, 0x3f	; 63
   6:	0f 92       	push	r0
   8:	11 24       	eor	r1, r1
   a:	2f 93       	push	r18
   c:	3f 93       	push	r19
   e:	4f 93       	push	r20
  10:	5f 93       	push	r21
  12:	6f 93       	push	r22
  14:	7f 93       	push	r23
  16:	8f 93       	push	r24
  18:	9f 93       	push	r25
  1a:	af 93       	push	r26
  1c:	bf 93       	push	r27
  1e:	ef 93       	push	r30
  20:	ff 93       	push	r31
******************************************************************************/

/* static */
inline void NewSoftSerial::handle_interrupts(int lopin, int hipin)
{
  if (active_object && 
  22:	e0 91 00 00 	lds	r30, 0x0000
  26:	f0 91 00 00 	lds	r31, 0x0000
  2a:	30 97       	sbiw	r30, 0x00	; 0
  2c:	01 f0       	breq	.+0      	; 0x2e <__vector_3+0x2e>
  2e:	82 81       	ldd	r24, Z+2	; 0x02
  30:	90 e0       	ldi	r25, 0x00	; 0
  32:	88 30       	cpi	r24, 0x08	; 8
  34:	91 05       	cpc	r25, r1
  36:	04 f0       	brlt	.+0      	; 0x38 <__vector_3+0x38>
  38:	0e 97       	sbiw	r24, 0x0e	; 14
  3a:	04 f4       	brge	.+0      	; 0x3c <__vector_3+0x3c>
    active_object->_receivePin >= lopin && 
    active_object->_receivePin <= hipin)
  {
    active_object->recv();
  3c:	cf 01       	movw	r24, r30
  3e:	0e 94 00 00 	call	0	; 0x0 <__vector_3>
}

SIGNAL(SIG_PIN_CHANGE0) 
{
  NewSoftSerial::handle_interrupts(8, 13);
}
  42:	ff 91       	pop	r31
  44:	ef 91       	pop	r30
  46:	bf 91       	pop	r27
  48:	af 91       	pop	r26
  4a:	9f 91       	pop	r25
  4c:	8f 91       	pop	r24
  4e:	7f 91       	pop	r23
  50:	6f 91       	pop	r22
  52:	5f 91       	pop	r21
  54:	4f 91       	pop	r20
  56:	3f 91       	pop	r19
  58:	2f 91       	pop	r18
  5a:	0f 90       	pop	r0
  5c:	0f be       	out	0x3f, r0	; 63
  5e:	0f 90       	pop	r0
  60:	1f 90       	pop	r1
  62:	18 95       	reti
