LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: digitalWrite
void digitalWrite (int pin, int value)
{
  struct wiringPiNodeStruct *node = wiringPiNodes ;

  if ((pin & PI_GPIO_MASK) == 0)		// On-Board Pin
  {
    /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)	// Sys mode
    {
      if (sysFds [pin] != -1)
      {
	if (value == LOW)
	  write (sysFds [pin], "0\n", 2) ;
	else
	  write (sysFds [pin], "1\n", 2) ;
      }
      return ;
    }
    else if (wiringPiMode == WPI_MODE_PINS)
      pin = pinToGpio [pin] ;
    else if (wiringPiMode == WPI_MODE_PHYS)
      pin = physToGpio [pin] ;
    else if (wiringPiMode != WPI_MODE_GPIO)
      return ;

    if (value == LOW)
      *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
    else
      *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
  }
  else
  {
    if ((node = wiringPiFindNode (pin)) != NULL)
      node->digitalWrite (node, pin, value) ;
  }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movq 0x2faed(%rip), %rax     # 0x5bfb0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
andl $-0x40, %eax
cmpl $0x0, %eax
jne 0x2c5f7
cmpl $0x2, 0x307f2(%rip)     # 0x5ccd4
jne 0x2c546
movslq 0x14(%rsp), %rcx
leaq 0x30930(%rip), %rax     # 0x5ce20
cmpl $-0x1, (%rax,%rcx,4)
je 0x2c541
cmpl $0x0, 0x10(%rsp)
jne 0x2c51f
movslq 0x14(%rsp), %rcx
leaq 0x30917(%rip), %rax     # 0x5ce20
movl (%rax,%rcx,4), %edi
leaq 0x1f23b(%rip), %rsi     # 0x4b74e
movl $0x2, %edx
callq 0x22320
jmp 0x2c53f
movslq 0x14(%rsp), %rcx
leaq 0x308f5(%rip), %rax     # 0x5ce20
movl (%rax,%rcx,4), %edi
leaq 0x1f21c(%rip), %rsi     # 0x4b751
movl $0x2, %edx
callq 0x22320
jmp 0x2c541
jmp 0x2c625
cmpl $0x0, 0x30787(%rip)     # 0x5ccd4
jne 0x2c564
movq 0x31742(%rip), %rax     # 0x5dc98
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
jmp 0x2c594
cmpl $0x3, 0x30769(%rip)     # 0x5ccd4
jne 0x2c582
movq 0x3172c(%rip), %rax     # 0x5dca0
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
jmp 0x2c592
cmpl $0x1, 0x3074b(%rip)     # 0x5ccd4
je 0x2c590
jmp 0x2c625
jmp 0x2c592
jmp 0x2c594
jmp 0x2c596
cmpl $0x0, 0x10(%rsp)
jne 0x2c5ca
movl 0x14(%rsp), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movq 0x316fe(%rip), %rax     # 0x5dcb0
movslq 0x14(%rsp), %rsi
leaq 0x309a2(%rip), %rcx     # 0x5cf60
movzbl (%rcx,%rsi), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2c5f5
movl 0x14(%rsp), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movq 0x316d1(%rip), %rax     # 0x5dcb0
movslq 0x14(%rsp), %rsi
leaq 0x309b5(%rip), %rcx     # 0x5cfa0
movzbl (%rcx,%rsi), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2c625
movl 0x14(%rsp), %edi
callq 0x22cd0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2c623
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq *%rax
jmp 0x2c625
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: pwmWrite
void pwmWrite (int pin, int value)
{
  struct wiringPiNodeStruct *node = wiringPiNodes ;

  setupCheck ("pwmWrite") ;

  if ((pin & PI_GPIO_MASK) == 0)		// On-Board Pin
  {
    /**/ if (wiringPiMode == WPI_MODE_PINS)
      pin = pinToGpio [pin] ;
    else if (wiringPiMode == WPI_MODE_PHYS)
      pin = physToGpio [pin] ;
    else if (wiringPiMode != WPI_MODE_GPIO)
      return ;

    usingGpioMemCheck ("pwmWrite") ;
    *(pwm + gpioToPwmPort [pin]) = value ;
  }
  else
  {
    if ((node = wiringPiFindNode (pin)) != NULL)
      node->pwmWrite (node, pin, value) ;
  }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movq 0x2f96d(%rip), %rax     # 0x5bfb0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x1f102(%rip), %rdi     # 0x4b754
callq 0x2bd90
movl 0x14(%rsp), %eax
andl $-0x40, %eax
cmpl $0x0, %eax
jne 0x2c6dd
cmpl $0x0, 0x3066a(%rip)     # 0x5ccd4
jne 0x2c681
movq 0x31625(%rip), %rax     # 0x5dc98
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
jmp 0x2c6ae
cmpl $0x3, 0x3064c(%rip)     # 0x5ccd4
jne 0x2c69f
movq 0x3160f(%rip), %rax     # 0x5dca0
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
jmp 0x2c6ac
cmpl $0x1, 0x3062e(%rip)     # 0x5ccd4
je 0x2c6aa
jmp 0x2c70b
jmp 0x2c6ac
jmp 0x2c6ae
leaq 0x1f09f(%rip), %rdi     # 0x4b754
callq 0x2c0d0
movl 0x10(%rsp), %edx
movq 0x315f3(%rip), %rax     # 0x5dcb8
movslq 0x14(%rsp), %rsi
leaq 0x30d9f(%rip), %rcx     # 0x5d470
movzbl (%rcx,%rsi), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2c70b
movl 0x14(%rsp), %edi
callq 0x22cd0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2c709
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq *%rax
jmp 0x2c70b
addq $0x18, %rsp
retq
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: analogRead
int analogRead (int pin)
{
  struct wiringPiNodeStruct *node = wiringPiNodes ;

  if ((node = wiringPiFindNode (pin)) == NULL)
    return 0 ;
  else
    return node->analogRead (node, pin) ;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq 0x2f891(%rip), %rax     # 0x5bfb0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %edi
callq 0x22cd0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x2c745
movl $0x0, 0x14(%rsp)
jmp 0x2c75d
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq *%rax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: analogWrite
void analogWrite (int pin, int value)
{
  struct wiringPiNodeStruct *node = wiringPiNodes ;

  if ((node = wiringPiFindNode (pin)) == NULL)
    return ;

  node->analogWrite (node, pin, value) ;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movq 0x2f82d(%rip), %rax     # 0x5bfb0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %edi
callq 0x22cd0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x2c7a1
jmp 0x2c7b9
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq *%rax
addq $0x18, %rsp
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: pwmToneWrite
void pwmToneWrite (int pin, int freq)
{
  int range ;

  setupCheck ("pwmToneWrite") ;

  if (freq == 0)
    pwmWrite (pin, 0) ;             // Off
  else
  {
    range = 600000 / freq ;
    pwmSetRange (range) ;
    pwmWrite    (pin, freq / 2) ;
  }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
leaq 0x1ef8a(%rip), %rdi     # 0x4b75d
callq 0x2bd90
cmpl $0x0, 0x10(%rsp)
jne 0x2c7ec
movl 0x14(%rsp), %edi
xorl %esi, %esi
callq 0x22370
jmp 0x2c81a
movl $0x927c0, %eax          # imm = 0x927C0
cltd
idivl 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x22700
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
callq 0x22370
addq $0x18, %rsp
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: digitalWriteByte
void digitalWriteByte (const int value)
{
  uint32_t pinSet = 0 ;
  uint32_t pinClr = 0 ;
  int mask = 1 ;
  int pin ;

  /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
  {
    for (pin = 0 ; pin < 8 ; ++pin)
    {
      digitalWrite (pinToGpio [pin], value & mask) ;
      mask <<= 1 ;
    }
    return ;
  }
  else
  {
    for (pin = 0 ; pin < 8 ; ++pin)
    {
      if ((value & mask) == 0)
	pinClr |= (1 << pinToGpio [pin]) ;
      else
	pinSet |= (1 << pinToGpio [pin]) ;

      mask <<= 1 ;
    }

    *(gpio + gpioToGPCLR [0]) = pinClr ;
    *(gpio + gpioToGPSET [0]) = pinSet ;
  }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
cmpl $0x2, 0x3048d(%rip)     # 0x5ccd4
jne 0x2c890
movl $0x0, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jge 0x2c88b
movq 0x31439(%rip), %rax     # 0x5dc98
movslq 0x4(%rsp), %rcx
movl (%rax,%rcx,4), %edi
movl 0x14(%rsp), %esi
andl 0x8(%rsp), %esi
callq 0x235e0
movl 0x8(%rsp), %eax
shll %eax
movl %eax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2c851
jmp 0x2c931
movl $0x0, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jge 0x2c901
movl 0x14(%rsp), %eax
andl 0x8(%rsp), %eax
cmpl $0x0, %eax
jne 0x2c8cc
movq 0x313e5(%rip), %rax     # 0x5dc98
movslq 0x4(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movl $0x1, %eax
shll %cl, %eax
orl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x2c8ea
movq 0x313c5(%rip), %rax     # 0x5dc98
movslq 0x4(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movl $0x1, %eax
shll %cl, %eax
orl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x8(%rsp), %eax
shll %eax
movl %eax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2c898
movl 0xc(%rsp), %edx
movq 0x313a4(%rip), %rax     # 0x5dcb0
movzbl 0x3064d(%rip), %ecx     # 0x5cf60
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x10(%rsp), %edx
movq 0x3138c(%rip), %rax     # 0x5dcb0
movzbl 0x30675(%rip), %ecx     # 0x5cfa0
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: digitalReadByte
unsigned int digitalReadByte (void)
{
  int pin, x ;
  uint32_t raw ;
  uint32_t data = 0 ;

  /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
  {
    for (pin = 0 ; pin < 8 ; ++pin)
    {
      x = digitalRead (pinToGpio [pin]) ;
      data = (data << 1) | x ;
    }
  }
  else
  {
    raw = *(gpio + gpioToGPLEV [0]) ; // First bank for these pins
    for (pin = 0 ; pin < 8 ; ++pin)
    {
      x = pinToGpio [pin] ;
      data = (data << 1) | (((raw & (1 << x)) == 0) ? 0 : 1) ;
    }
  }
  return data ;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x8(%rsp)
cmpl $0x2, 0x30381(%rip)     # 0x5ccd4
jne 0x2c999
movl $0x0, 0x14(%rsp)
cmpl $0x8, 0x14(%rsp)
jge 0x2c997
movq 0x3132d(%rip), %rax     # 0x5dc98
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x22360
movl %eax, 0x10(%rsp)
movl 0x8(%rsp), %eax
shll %eax
orl 0x10(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2c95d
jmp 0x2ca0e
movq 0x31310(%rip), %rax     # 0x5dcb0
movzbl 0x30579(%rip), %ecx     # 0x5cf20
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x8, 0x14(%rsp)
jge 0x2ca0c
movq 0x312d1(%rip), %rax     # 0x5dc98
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
movl 0x8(%rsp), %eax
shll %eax
movl 0xc(%rsp), %esi
movl 0x10(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %esi
movl $0x1, %ecx
xorl %edx, %edx
cmpl $0x0, %esi
cmovel %edx, %ecx
orl %ecx, %eax
movl %eax, 0x8(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2c9b9
jmp 0x2ca0e
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: digitalWriteByte2
void digitalWriteByte2 (const int value)
{
  register int mask = 1 ;
  register int pin ;

  /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
  {
    for (pin = 20 ; pin < 28 ; ++pin)
    {
      digitalWrite (pin, value & mask) ;
      mask <<= 1 ;
    }
    return ;
  }
  else
  {
    *(gpio + gpioToGPCLR [0]) = (~value & 0xFF) << 20 ; // 0x0FF00000; ILJ > CHANGE: Old causes glitch
    *(gpio + gpioToGPSET [0]) = ( value & 0xFF) << 20 ;
  }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x1, 0x10(%rsp)
cmpl $0x2, 0x3029d(%rip)     # 0x5ccd4
jne 0x2ca72
movl $0x14, 0xc(%rsp)
cmpl $0x1c, 0xc(%rsp)
jge 0x2ca70
movl 0xc(%rsp), %edi
movl 0x14(%rsp), %esi
andl 0x10(%rsp), %esi
callq 0x235e0
movl 0x10(%rsp), %eax
shll %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2ca41
jmp 0x2cab7
movl 0x14(%rsp), %edx
xorl $-0x1, %edx
andl $0xff, %edx
shll $0x14, %edx
movq 0x31227(%rip), %rax     # 0x5dcb0
movzbl 0x304d0(%rip), %ecx     # 0x5cf60
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x14(%rsp), %edx
andl $0xff, %edx
shll $0x14, %edx
movq 0x31206(%rip), %rax     # 0x5dcb0
movzbl 0x304ef(%rip), %ecx     # 0x5cfa0
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x18, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: digitalReadByte2
unsigned int digitalReadByte2 (void)
{
  int pin, x ;
  uint32_t data = 0 ;

  /**/ if (wiringPiMode == WPI_MODE_GPIO_SYS)
  {
    for (pin = 20 ; pin < 28 ; ++pin)
    {
      x = digitalRead (pin) ;
      data = (data << 1) | x ;
    }
  }
  else
    data = ((*(gpio + gpioToGPLEV [0])) >> 20) & 0xFF ; // First bank for these pins

  return data ;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0xc(%rsp)
cmpl $0x2, 0x30201(%rip)     # 0x5ccd4
jne 0x2cb0e
movl $0x14, 0x14(%rsp)
cmpl $0x1c, 0x14(%rsp)
jge 0x2cb0c
movl 0x14(%rsp), %edi
callq 0x22360
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
shll %eax
orl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2cadd
jmp 0x2cb2e
movq 0x3119b(%rip), %rax     # 0x5dcb0
movzbl 0x30404(%rip), %ecx     # 0x5cf20
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
shrl $0x14, %eax
andl $0xff, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: waitForInterrupt
int waitForInterrupt (int pin, int mS)
{
  int fd, x ;
  uint8_t c ;
  struct pollfd polls ;

  /**/ if (wiringPiMode == WPI_MODE_PINS)
    pin = pinToGpio [pin] ;
  else if (wiringPiMode == WPI_MODE_PHYS)
    pin = physToGpio [pin] ;

  if ((fd = sysFds [pin]) == -1)
    return -2 ;

// Setup poll structure

  polls.fd     = fd ;
  polls.events = POLLPRI | POLLERR ;

// Wait for it ...

  x = poll (&polls, 1, mS) ;

// If no error, do a dummy read to clear the interrupt
//	A one character read appars to be enough.

  if (x > 0)
  {
    lseek (fd, 0, SEEK_SET) ;	// Rewind
    (void)read (fd, &c, 1) ;	// Read & clear
  }

  return x ;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
cmpl $0x0, 0x30181(%rip)     # 0x5ccd4
jne 0x2cb6a
movq 0x3113c(%rip), %rax     # 0x5dc98
movslq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x20(%rsp)
jmp 0x2cb88
cmpl $0x3, 0x30163(%rip)     # 0x5ccd4
jne 0x2cb86
movq 0x31126(%rip), %rax     # 0x5dca0
movslq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x20(%rsp)
jmp 0x2cb88
movslq 0x20(%rsp), %rcx
leaq 0x3028c(%rip), %rax     # 0x5ce20
movl (%rax,%rcx,4), %eax
movl %eax, 0x18(%rsp)
cmpl $-0x1, %eax
jne 0x2cbaa
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0x2cc01
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsp)
movw $0xa, 0xc(%rsp)
movl 0x1c(%rsp), %edx
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x23090
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x2cbf9
movl 0x18(%rsp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x234a0
movl 0x18(%rsp), %edi
leaq 0x13(%rsp), %rsi
movl $0x1, %edx
callq 0x23030
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: interruptHandler
static void *interruptHandler (UNU void *arg)
{
  int myPin ;

  (void)piHiPri (55) ;	// Only effective if we run as root

  myPin   = pinPass ;
  pinPass = -1 ;

  for (;;)
    if (waitForInterrupt (myPin, -1) > 0)
      isrFunctions [myPin] () ;

  return NULL ;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x37, %edi
callq 0x22170
movl 0x2ffb7(%rip), %eax     # 0x5cfe0
movl %eax, 0xc(%rsp)
movl $0xffffffff, 0x2ffa9(%rip) # imm = 0xFFFFFFFF
movl 0xc(%rsp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x221d0
cmpl $0x0, %eax
jle 0x2d059
movslq 0xc(%rsp), %rcx
leaq 0x30c8a(%rip), %rax     # 0x5dce0
callq *(%rax,%rcx,8)
jmp 0x2d037
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: delayMicrosecondsHard
void delayMicrosecondsHard (unsigned int howLong)
{
  struct timeval tNow, tLong, tEnd ;

  gettimeofday (&tNow, NULL) ;
  tLong.tv_sec  = howLong / 1000000 ;
  tLong.tv_usec = howLong % 1000000 ;
  timeradd (&tNow, &tLong, &tEnd) ;

  while (timercmp (&tNow, &tEnd, <))
    gettimeofday (&tNow, NULL) ;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x231b0
movl 0x44(%rsp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movq %rax, 0x20(%rsp)
movl 0x44(%rsp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0xf4240, 0x18(%rsp)    # imm = 0xF4240
jl 0x2d135
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
subq $0xf4240, %rax          # imm = 0xF4240
movq %rax, 0x18(%rsp)
jmp 0x2d137
jmp 0x2d139
movq 0x30(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x2d15d
movq 0x38(%rsp), %rax
cmpq 0x18(%rsp), %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
jmp 0x2d173
movq 0x30(%rsp), %rax
cmpq 0x10(%rsp), %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
je 0x2d18c
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x231b0
jmp 0x2d139
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: wiringPiSetupGpio
int wiringPiSetupGpio (void)
{
  (void)wiringPiSetup () ;

  if (wiringPiDebug)
    printf ("wiringPi: wiringPiSetupGpio called\n") ;

  wiringPiMode = WPI_MODE_GPIO ;

  return 0 ;
}

// Assembly:
pushq %rax
callq 0x23300
movq 0x2e713(%rip), %rax     # 0x5bf40
cmpl $0x0, (%rax)
je 0x2d840
leaq 0x1e255(%rip), %rdi     # 0x4ba8e
movb $0x0, %al
callq 0x22060
movl $0x1, 0x2f48a(%rip)     # 0x5ccd4
xorl %eax, %eax
popq %rcx
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: wiringPiSetupPhys
int wiringPiSetupPhys (void)
{
  (void)wiringPiSetup () ;

  if (wiringPiDebug)
    printf ("wiringPi: wiringPiSetupPhys called\n") ;

  wiringPiMode = WPI_MODE_PHYS ;

  return 0 ;
}

// Assembly:
pushq %rax
callq 0x23300
movq 0x2e6e3(%rip), %rax     # 0x5bf40
cmpl $0x0, (%rax)
je 0x2d870
leaq 0x1e249(%rip), %rdi     # 0x4bab2
movb $0x0, %al
callq 0x22060
movl $0x3, 0x2f45a(%rip)     # 0x5ccd4
xorl %eax, %eax
popq %rcx
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: wiringPiSetupSys
int wiringPiSetupSys (void)
{
  int pin ;
  char fName [128] ;

  if (wiringPiSetuped)
    return 0 ;

  wiringPiSetuped = TRUE ;

  if (getenv (ENV_DEBUG) != NULL)
    wiringPiDebug = TRUE ;

  if (getenv (ENV_CODES) != NULL)
    wiringPiReturnCodes = TRUE ;

  if (wiringPiDebug)
    printf ("wiringPi: wiringPiSetupSys called\n") ;

  if (piGpioLayout () == 1)
  {
     pinToGpio =  pinToGpioR1 ;
    physToGpio = physToGpioR1 ;
  }
  else
  {
     pinToGpio =  pinToGpioR2 ;
    physToGpio = physToGpioR2 ;
  }

// Open and scan the directory, looking for exported GPIOs, and pre-open
//	the 'value' interface to speed things up for later

  for (pin = 0 ; pin < 64 ; ++pin)
  {
    sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
    sysFds [pin] = open (fName, O_RDWR) ;
  }

  initialiseEpoch () ;

  wiringPiMode = WPI_MODE_GPIO_SYS ;

  return 0 ;
}

// Assembly:
subq $0x88, %rsp
cmpl $0x0, 0x3068a(%rip)     # 0x5df18
je 0x2d8a0
movl $0x0, 0x84(%rsp)
jmp 0x2d9c3
movl $0x1, 0x3066e(%rip)     # 0x5df18
leaq 0x1e004(%rip), %rdi     # 0x4b8b5
callq 0x22d30
cmpq $0x0, %rax
je 0x2d8c9
movq 0x2e67d(%rip), %rax     # 0x5bf40
movl $0x1, (%rax)
leaq 0x1dff4(%rip), %rdi     # 0x4b8c4
callq 0x22d30
cmpq $0x0, %rax
je 0x2d8e8
movq 0x2e6c6(%rip), %rax     # 0x5bfa8
movl $0x1, (%rax)
movq 0x2e651(%rip), %rax     # 0x5bf40
cmpl $0x0, (%rax)
je 0x2d902
leaq 0x1e1db(%rip), %rdi     # 0x4bad6
movb $0x0, %al
callq 0x22060
callq 0x235b0
cmpl $0x1, %eax
jne 0x2d92a
leaq 0x2f6dd(%rip), %rax     # 0x5cff0
movq %rax, 0x3037e(%rip)     # 0x5dc98
leaq 0x2f7cf(%rip), %rax     # 0x5d0f0
movq %rax, 0x30378(%rip)     # 0x5dca0
jmp 0x2d946
leaq 0x2f8bf(%rip), %rax     # 0x5d1f0
movq %rax, 0x30360(%rip)     # 0x5dc98
leaq 0x2f9b1(%rip), %rax     # 0x5d2f0
movq %rax, 0x3035a(%rip)     # 0x5dca0
movl $0x0, 0x80(%rsp)
cmpl $0x40, 0x80(%rsp)
jge 0x2d9a9
movq %rsp, %rdi
movl 0x80(%rsp), %edx
leaq 0x1df08(%rip), %rsi     # 0x4b874
movb $0x0, %al
callq 0x220d0
movq %rsp, %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x227b0
movl %eax, %edx
movslq 0x80(%rsp), %rcx
leaq 0x2f48d(%rip), %rax     # 0x5ce20
movl %edx, (%rax,%rcx,4)
movl 0x80(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x80(%rsp)
jmp 0x2d951
callq 0x2d7a0
movl $0x2, 0x2f31c(%rip)     # 0x5ccd4
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/BMA150/BMA150.cpp
// Function: BMA150::getAcceleration(short*, short*, short*)
void BMA150::getAcceleration(int16_t* x, int16_t* y, int16_t* z) {
    I2Cdev::readBytes(devAddr, BMA150_RA_X_AXIS_LSB, 6, buffer);
    *x = ((((int16_t)buffer[1]) << 8) | buffer[0]) >> 6;
    *y = ((((int16_t)buffer[3]) << 8) | buffer[2]) >> 6;
    *z = ((((int16_t)buffer[5]) << 8) | buffer[4]) >> 6;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
movl $0x2, %esi
movl $0x6, %edx
movq 0x2e37f(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x1(%rcx), %edx
orl %edx, %eax
sarl $0x6, %eax
movw %ax, %dx
movq 0x18(%rsp), %rax
movw %dx, (%rax)
movzbl 0x4(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x3(%rcx), %edx
orl %edx, %eax
sarl $0x6, %eax
movw %ax, %dx
movq 0x10(%rsp), %rax
movw %dx, (%rax)
movzbl 0x6(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x5(%rcx), %ecx
orl %ecx, %eax
sarl $0x6, %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/BMP085/BMP085.cpp
// Function: BMP085::loadCalibration()
void BMP085::loadCalibration() {
    uint8_t buf2[22];
    I2Cdev::readBytes(devAddr, BMP085_RA_AC1_H, 22, buf2);
    ac1 = ((int16_t)buf2[0] << 8) + buf2[1];
    ac2 = ((int16_t)buf2[2] << 8) + buf2[3];
    ac3 = ((int16_t)buf2[4] << 8) + buf2[5];
    ac4 = ((uint16_t)buf2[6] << 8) + buf2[7];
    ac5 = ((uint16_t)buf2[8] << 8) + buf2[9];
    ac6 = ((uint16_t)buf2[10] << 8) + buf2[11];
    b1 = ((int16_t)buf2[12] << 8) + buf2[13];
    b2 = ((int16_t)buf2[14] << 8) + buf2[15];
    mb = ((int16_t)buf2[16] << 8) + buf2[17];
    mc = ((int16_t)buf2[18] << 8) + buf2[19];
    md = ((int16_t)buf2[20] << 8) + buf2[21];
    calibrationLoaded = true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movb (%rax), %dil
leaq 0x10(%rsp), %rcx
movl $0xaa, %esi
movl $0x16, %edx
movq 0x2cc5c(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq 0x8(%rsp), %rax
movzbl 0x10(%rsp), %ecx
movswl %cx, %ecx
shll $0x8, %ecx
movzbl 0x11(%rsp), %edx
addl %edx, %ecx
movw %cx, 0x6(%rax)
movzbl 0x12(%rsp), %ecx
movswl %cx, %ecx
shll $0x8, %ecx
movzbl 0x13(%rsp), %edx
addl %edx, %ecx
movw %cx, 0x8(%rax)
movzbl 0x14(%rsp), %ecx
movswl %cx, %ecx
shll $0x8, %ecx
movzbl 0x15(%rsp), %edx
addl %edx, %ecx
movw %cx, 0xa(%rax)
movzbl 0x16(%rsp), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
movzbl 0x17(%rsp), %edx
addl %edx, %ecx
movw %cx, 0x16(%rax)
movzbl 0x18(%rsp), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
movzbl 0x19(%rsp), %edx
addl %edx, %ecx
movw %cx, 0x18(%rax)
movzbl 0x1a(%rsp), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
movzbl 0x1b(%rsp), %edx
addl %edx, %ecx
movw %cx, 0x1a(%rax)
movzbl 0x1c(%rsp), %ecx
movswl %cx, %ecx
shll $0x8, %ecx
movzbl 0x1d(%rsp), %edx
addl %edx, %ecx
movw %cx, 0xc(%rax)
movzbl 0x1e(%rsp), %ecx
movswl %cx, %ecx
shll $0x8, %ecx
movzbl 0x1f(%rsp), %edx
addl %edx, %ecx
movw %cx, 0xe(%rax)
movzbl 0x20(%rsp), %ecx
movswl %cx, %ecx
shll $0x8, %ecx
movzbl 0x21(%rsp), %edx
addl %edx, %ecx
movw %cx, 0x10(%rax)
movzbl 0x22(%rsp), %ecx
movswl %cx, %ecx
shll $0x8, %ecx
movzbl 0x23(%rsp), %edx
addl %edx, %ecx
movw %cx, 0x12(%rax)
movzbl 0x24(%rsp), %ecx
movswl %cx, %ecx
shll $0x8, %ecx
movzbl 0x25(%rsp), %edx
addl %edx, %ecx
movw %cx, 0x14(%rax)
movb $0x1, 0x4(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/BMP085/BMP085.cpp
// Function: BMP085::getMeasurement2()
uint16_t BMP085::getMeasurement2() {
    // wait for end of conversion
    while(getControl() & 0x20);
    I2Cdev::readBytes(devAddr, BMP085_RA_MSB, 2, buffer);
    return ((uint16_t)buffer[0] << 8) + buffer[1];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x22c00
movzbl %al, %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x2f4ba
jmp 0x2f4a3
movq 0x8(%rsp), %rcx
movb (%rcx), %dil
addq $0x1, %rcx
movl $0xf6, %esi
movl $0x2, %edx
movq 0x2ca41(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq 0x8(%rsp), %rcx
movzbl 0x1(%rcx), %eax
movzwl %ax, %eax
shll $0x8, %eax
movzbl 0x2(%rcx), %ecx
addl %ecx, %eax
addq $0x18, %rsp
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/BMP085/BMP085.cpp
// Function: BMP085::getMeasurement3()
uint32_t BMP085::getMeasurement3() {
    // wait for end of conversion
    while(getControl() & 0x20);
    I2Cdev::readBytes(devAddr, BMP085_RA_MSB, 3, buffer);
    return ((uint32_t)buffer[0] << 16) + ((uint16_t)buffer[1] << 8) + buffer[2];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x22c00
movzbl %al, %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x2f52a
jmp 0x2f513
movq 0x8(%rsp), %rcx
movb (%rcx), %dil
addq $0x1, %rcx
movl $0xf6, %esi
movl $0x3, %edx
movq 0x2c9d1(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq 0x8(%rsp), %rcx
movzbl 0x1(%rcx), %eax
shll $0x10, %eax
movzbl 0x2(%rcx), %edx
movzwl %dx, %edx
shll $0x8, %edx
addl %edx, %eax
movzbl 0x3(%rcx), %ecx
addl %ecx, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/BMP085/BMP085.cpp
// Function: BMP085::getMeasureDelayMilliseconds(unsigned char)
uint8_t BMP085::getMeasureDelayMilliseconds(uint8_t mode) {
    if (mode == 0) mode = measureMode;
    if (measureMode == 0x2E) return 5;
    else if (measureMode == 0x34) return 5;
    else if (measureMode == 0x74) return 8;
    else if (measureMode == 0xB4) return 14;
    else if (measureMode == 0xF4) return 26;
    return 0; // invalid mode
}

// Assembly:
movb %sil, %al
movq %rdi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movzbl -0x11(%rsp), %eax
cmpl $0x0, %eax
jne 0x2f5ac
movq -0x20(%rsp), %rax
movb 0x20(%rax), %al
movb %al, -0x11(%rsp)
movq -0x20(%rsp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x2e, %eax
jne 0x2f5c1
movb $0x5, -0x1(%rsp)
jmp 0x2f626
movq -0x20(%rsp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x34, %eax
jne 0x2f5d6
movb $0x5, -0x1(%rsp)
jmp 0x2f626
movq -0x20(%rsp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x74, %eax
jne 0x2f5eb
movb $0x8, -0x1(%rsp)
jmp 0x2f626
movq -0x20(%rsp), %rax
movzbl 0x20(%rax), %eax
cmpl $0xb4, %eax
jne 0x2f602
movb $0xe, -0x1(%rsp)
jmp 0x2f626
movq -0x20(%rsp), %rax
movzbl 0x20(%rax), %eax
cmpl $0xf4, %eax
jne 0x2f619
movb $0x1a, -0x1(%rsp)
jmp 0x2f626
jmp 0x2f61b
jmp 0x2f61d
jmp 0x2f61f
jmp 0x2f621
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/BMP085/BMP085.cpp
// Function: BMP085::getMeasureDelayMicroseconds(unsigned char)
uint16_t BMP085::getMeasureDelayMicroseconds(uint8_t mode) {
    if (mode == 0) mode = measureMode;
    if (measureMode == 0x2E) return 4500;
    else if (measureMode == 0x34) return 4500;
    else if (measureMode == 0x74) return 7500;
    else if (measureMode == 0xB4) return 13500;
    else if (measureMode == 0xF4) return 25500;
    return 0; // invalid mode
}

// Assembly:
movb %sil, %al
movq %rdi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movzbl -0x11(%rsp), %eax
cmpl $0x0, %eax
jne 0x2f65c
movq -0x20(%rsp), %rax
movb 0x20(%rax), %al
movb %al, -0x11(%rsp)
movq -0x20(%rsp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x2e, %eax
jne 0x2f673
movw $0x1194, -0x2(%rsp)     # imm = 0x1194
jmp 0x2f6e2
movq -0x20(%rsp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x34, %eax
jne 0x2f68a
movw $0x1194, -0x2(%rsp)     # imm = 0x1194
jmp 0x2f6e2
movq -0x20(%rsp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x74, %eax
jne 0x2f6a1
movw $0x1d4c, -0x2(%rsp)     # imm = 0x1D4C
jmp 0x2f6e2
movq -0x20(%rsp), %rax
movzbl 0x20(%rax), %eax
cmpl $0xb4, %eax
jne 0x2f6ba
movw $0x34bc, -0x2(%rsp)     # imm = 0x34BC
jmp 0x2f6e2
movq -0x20(%rsp), %rax
movzbl 0x20(%rax), %eax
cmpl $0xf4, %eax
jne 0x2f6d3
movw $0x639c, -0x2(%rsp)     # imm = 0x639C
jmp 0x2f6e2
jmp 0x2f6d5
jmp 0x2f6d7
jmp 0x2f6d9
jmp 0x2f6db
movw $0x0, -0x2(%rsp)
movw -0x2(%rsp), %ax
retq
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/BMP085/BMP085.cpp
// Function: BMP085::getTemperatureC()
float BMP085::getTemperatureC() {
    /*
    Datasheet formula:
        UT = raw temperature
        X1 = (UT - AC6) * AC5 / 2^15
        X2 = MC * 2^11 / (X1 + MD)
        B5 = X1 + X2
        T = (B5 + 8) / 2^4
    */
    int32_t ut = getRawTemperature();
    if(ut == 0) return NAN;
    int32_t x1 = ((ut - (int32_t)ac6) * (int32_t)ac5) >> 15;
    int32_t x2 = ((int32_t)mc << 11) / (x1 + md);
    b5 = x1 + x2;
    return (float)((b5 + 8) >> 4) / 10.0f;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x22350
movzwl %ax, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x2f765
movss 0x1c4f7(%rip), %xmm0    # 0x4bc54
movss %xmm0, 0x24(%rsp)
jmp 0x2f7c9
movq (%rsp), %rdx
movl 0x14(%rsp), %eax
movzwl 0x1a(%rdx), %ecx
subl %ecx, %eax
movzwl 0x18(%rdx), %ecx
imull %ecx, %eax
sarl $0xf, %eax
movl %eax, 0x10(%rsp)
movswl 0x12(%rdx), %eax
shll $0xb, %eax
movl 0x10(%rsp), %ecx
movswl 0x14(%rdx), %edx
addl %edx, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0xc(%rsp)
movl 0x10(%rsp), %ecx
addl 0xc(%rsp), %ecx
movl %ecx, 0x1c(%rax)
movl 0x1c(%rax), %eax
addl $0x8, %eax
sarl $0x4, %eax
cvtsi2ss %eax, %xmm0
movss 0x1c491(%rip), %xmm1    # 0x4bc50
divss %xmm1, %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x24(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DS1307::getSeconds()
uint8_t DS1307::getSeconds() {
    // Byte: [7 = CH] [6:4 = 10SEC] [3:0 = 1SEC]
    I2Cdev::readByte(devAddr, DS1307_RA_SECONDS, buffer);
    clockHalt = buffer[0] & 0x80;
    return (buffer[0] & 0x0F) + ((buffer[0] & 0x70) >> 4) * 10;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movb (%rdx), %cl
addq $0x1, %rdx
xorl %esi, %esi
movq 0x2c2a6(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22ce0
movq 0x8(%rsp), %rcx
movzbl 0x1(%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x3(%rcx)
movzbl 0x1(%rcx), %eax
andl $0xf, %eax
movzbl 0x1(%rcx), %ecx
andl $0x70, %ecx
sarl $0x4, %ecx
imull $0xa, %ecx, %ecx
addl %ecx, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DS1307::getHours12()
uint8_t DS1307::getHours12() {
    I2Cdev::readByte(devAddr, DS1307_RA_HOURS, buffer);
    mode12 = buffer[0] & 0x40;
    if (mode12) {
        // bit 6 is high, 12-hour mode
        // Byte: [5 = AM/PM] [4 = 10HR] [3:0 = 1HR]
        return (buffer[0] & 0x0F) + ((buffer[0] & 0x10) >> 4) * 10;
    } else {
        // bit 6 is low, 24-hour mode (default)
        // Byte: [5:4 = 10HR] [3:0 = 1HR]
        uint8_t hours = (buffer[0] & 0x0F) + ((buffer[0] & 0x30) >> 4) * 10;

        // convert 24-hour to 12-hour format, since that's what's requested
        if (hours > 12) hours -= 12;
        else if (hours == 0) hours = 12;
        return hours;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movb (%rdx), %cl
addq $0x1, %rdx
movl $0x2, %esi
movq 0x2c023(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22ce0
movq 0x8(%rsp), %rax
movzbl 0x1(%rax), %ecx
andl $0x40, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, 0x2(%rax)
testb $0x1, 0x2(%rax)
je 0x2ff3f
movq 0x8(%rsp), %rcx
movzbl 0x1(%rcx), %eax
andl $0xf, %eax
movzbl 0x1(%rcx), %ecx
andl $0x10, %ecx
sarl $0x4, %ecx
imull $0xa, %ecx, %ecx
addl %ecx, %eax
movb %al, 0x27(%rsp)
jmp 0x2ff8f
movq 0x8(%rsp), %rcx
movzbl 0x1(%rcx), %eax
andl $0xf, %eax
movzbl 0x1(%rcx), %ecx
andl $0x30, %ecx
sarl $0x4, %ecx
imull $0xa, %ecx, %ecx
addl %ecx, %eax
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0xc, %eax
jle 0x2ff76
movzbl 0x17(%rsp), %eax
subl $0xc, %eax
movb %al, 0x17(%rsp)
jmp 0x2ff87
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
jne 0x2ff85
movb $0xc, 0x17(%rsp)
jmp 0x2ff87
movb 0x17(%rsp), %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DS1307::setHours12(unsigned char, unsigned char)
void DS1307::setHours12(uint8_t hours, uint8_t ampm) {
    if (hours > 12 || hours < 1) return;
    if (mode12) {
        // bit 6 is high, 12-hour mode
        // Byte: [5 = AM/PM] [4 = 10HR] [3:0 = 1HR]
        if (ampm > 0) ampm = 0x20;
        uint8_t value = 0x40 + ampm + ((hours / 10) << 4) + (hours % 10);
        I2Cdev::writeByte(devAddr, DS1307_RA_HOURS, value);
    } else {
        // bit 6 is low, 24-hour mode (default)
        // Byte: [5:4 = 10HR] [3:0 = 1HR]
        if (ampm > 0) hours += 12;
        if (hours == 0) hours = 12; // 12 AM
        else if (hours == 24) hours = 12; // 12 PM, after +12 adjustment
        uint8_t value = ((hours / 10) << 4) + (hours % 10);
        I2Cdev::writeByte(devAddr, DS1307_RA_HOURS, value);
    }
}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, 0x10(%rsp)
movb %cl, 0xf(%rsp)
movb %al, 0xe(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xc, %eax
jg 0x2ffd3
movzbl 0xf(%rsp), %eax
cmpl $0x1, %eax
jge 0x2ffd8
jmp 0x300ad
movq (%rsp), %rax
testb $0x1, 0x2(%rax)
je 0x30038
movzbl 0xe(%rsp), %eax
cmpl $0x0, %eax
jle 0x2fff1
movb $0x20, 0xe(%rsp)
movzbl 0xe(%rsp), %ecx
addl $0x40, %ecx
movzbl 0xf(%rsp), %eax
movl $0xa, %esi
cltd
idivl %esi
shll $0x4, %eax
addl %eax, %ecx
movzbl 0xf(%rsp), %eax
movl $0xa, %esi
cltd
idivl %esi
movq (%rsp), %rax
addl %edx, %ecx
movb %cl, 0xd(%rsp)
movb (%rax), %al
movl $0x2, %esi
movzbl %al, %edi
movzbl 0xd(%rsp), %edx
callq 0x22ad0
jmp 0x300ad
movzbl 0xe(%rsp), %eax
cmpl $0x0, %eax
jle 0x3004e
movzbl 0xf(%rsp), %eax
addl $0xc, %eax
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x0, %eax
jne 0x3005f
movb $0xc, 0xf(%rsp)
jmp 0x30070
movzbl 0xf(%rsp), %eax
cmpl $0x18, %eax
jne 0x3006e
movb $0xc, 0xf(%rsp)
jmp 0x30070
movzbl 0xf(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
shll $0x4, %ecx
movzbl 0xf(%rsp), %eax
movl $0xa, %esi
cltd
idivl %esi
movq (%rsp), %rax
addl %edx, %ecx
movb %cl, 0xc(%rsp)
movb (%rax), %al
movl $0x2, %esi
movzbl %al, %edi
movzbl 0xc(%rsp), %edx
callq 0x22ad0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DS1307::getHours24()
uint8_t DS1307::getHours24() {
    I2Cdev::readByte(devAddr, DS1307_RA_HOURS, buffer);
    mode12 = buffer[0] & 0x40;
    if (mode12) {
        // bit 6 is high, 12-hour mode
        // Byte: [5 = AM/PM] [4 = 10HR] [3:0 = 1HR]
        uint8_t hours = (buffer[0] & 0x0F) + ((buffer[0] & 0x10) >> 4) * 10;

        // convert 12-hour to 24-hour format, since that's what's requested
        if (buffer[0] & 0x20) {
            // currently PM
            if (hours < 12) hours += 12;
        } else {
            // currently AM
            if (hours == 12) hours = 0;
        }
        return hours;
    } else {
        // bit 6 is low, 24-hour mode (default)
        // Byte: [5:4 = 10HR] [3:0 = 1HR]
        return (buffer[0] & 0x0F) + ((buffer[0] & 0x30) >> 4) * 10;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movb (%rdx), %cl
addq $0x1, %rdx
movl $0x2, %esi
movq 0x2be33(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22ce0
movq 0x8(%rsp), %rax
movzbl 0x1(%rax), %ecx
andl $0x40, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, 0x2(%rax)
testb $0x1, 0x2(%rax)
je 0x3016c
movq 0x8(%rsp), %rax
movzbl 0x1(%rax), %ecx
andl $0xf, %ecx
movzbl 0x1(%rax), %edx
andl $0x10, %edx
sarl $0x4, %edx
imull $0xa, %edx, %edx
addl %edx, %ecx
movb %cl, 0x17(%rsp)
movzbl 0x1(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x30151
movzbl 0x17(%rsp), %eax
cmpl $0xc, %eax
jge 0x3014f
movzbl 0x17(%rsp), %eax
addl $0xc, %eax
movb %al, 0x17(%rsp)
jmp 0x30162
movzbl 0x17(%rsp), %eax
cmpl $0xc, %eax
jne 0x30160
movb $0x0, 0x17(%rsp)
jmp 0x30162
movb 0x17(%rsp), %al
movb %al, 0x27(%rsp)
jmp 0x3018b
movq 0x8(%rsp), %rcx
movzbl 0x1(%rcx), %eax
andl $0xf, %eax
movzbl 0x1(%rcx), %ecx
andl $0x30, %ecx
sarl $0x4, %ecx
imull $0xa, %ecx, %ecx
addl %ecx, %eax
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DS1307::setHours24(unsigned char)
void DS1307::setHours24(uint8_t hours) {
    if (hours > 23) return;
    if (mode12) {
        // bit 6 is high, 12-hour mode
        // Byte: [5 = AM/PM] [4 = 10HR] [3:0 = 1HR]
        uint8_t ampm = 0;
        if (hours > 11) ampm = 0x20;
        if (hours > 12) hours -= 12;
        else if (hours == 0) hours = 12;
        uint8_t value = 0x40 + ampm + ((hours / 10) << 4) + (hours % 10);
        I2Cdev::writeByte(devAddr, DS1307_RA_HOURS, value);
    } else {
        // bit 6 is low, 24-hour mode (default)
        // Byte: [5:4 = 10HR] [3:0 = 1HR]
        uint8_t value = ((hours / 10) << 4) + (hours % 10);
        I2Cdev::writeByte(devAddr, DS1307_RA_HOURS, value);
    }
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x17, %eax
jle 0x301c8
jmp 0x30297
movq (%rsp), %rax
testb $0x1, 0x2(%rax)
je 0x3025a
movb $0x0, 0xe(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xb, %eax
jle 0x301ea
movb $0x20, 0xe(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xc, %eax
jle 0x30202
movzbl 0xf(%rsp), %eax
subl $0xc, %eax
movb %al, 0xf(%rsp)
jmp 0x30213
movzbl 0xf(%rsp), %eax
cmpl $0x0, %eax
jne 0x30211
movb $0xc, 0xf(%rsp)
jmp 0x30213
movzbl 0xe(%rsp), %ecx
addl $0x40, %ecx
movzbl 0xf(%rsp), %eax
movl $0xa, %esi
cltd
idivl %esi
shll $0x4, %eax
addl %eax, %ecx
movzbl 0xf(%rsp), %eax
movl $0xa, %esi
cltd
idivl %esi
movq (%rsp), %rax
addl %edx, %ecx
movb %cl, 0xd(%rsp)
movb (%rax), %al
movl $0x2, %esi
movzbl %al, %edi
movzbl 0xd(%rsp), %edx
callq 0x22ad0
jmp 0x30297
movzbl 0xf(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
shll $0x4, %ecx
movzbl 0xf(%rsp), %eax
movl $0xa, %esi
cltd
idivl %esi
movq (%rsp), %rax
addl %edx, %ecx
movb %cl, 0xc(%rsp)
movb (%rax), %al
movl $0x2, %esi
movzbl %al, %edi
movzbl 0xc(%rsp), %edx
callq 0x22ad0
addq $0x18, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DS1307::setYear(unsigned short)
void DS1307::setYear(uint16_t year) {
    if (year < 2000) return;
    year -= 2000;
    uint8_t value = ((year / 10) << 4) + (year % 10);
    I2Cdev::writeByte(devAddr, DS1307_RA_YEAR, value);
}

// Assembly:
subq $0x18, %rsp
movw %si, %ax
movq %rdi, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzwl 0xe(%rsp), %eax
cmpl $0x7d0, %eax            # imm = 0x7D0
jge 0x30558
jmp 0x305a4
movzwl 0xe(%rsp), %eax
subl $0x7d0, %eax            # imm = 0x7D0
movw %ax, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
shll $0x4, %ecx
movzwl 0xe(%rsp), %eax
movl $0xa, %esi
cltd
idivl %esi
movq (%rsp), %rax
addl %edx, %ecx
movb %cl, 0xd(%rsp)
movb (%rax), %al
movl $0x6, %esi
movzbl %al, %edi
movzbl 0xd(%rsp), %edx
callq 0x22ad0
addq $0x18, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DS1307::getTime12(unsigned char*, unsigned char*, unsigned char*, unsigned char*)
void DS1307::getTime12(uint8_t *hours, uint8_t *minutes, uint8_t *seconds, uint8_t *ampm) {
    *hours = getHours12();
    *minutes = getMinutes();
    *seconds = getSeconds();
    *ampm = getAMPM();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x22610
movq 0x8(%rsp), %rdi
movb %al, %cl
movq 0x28(%rsp), %rax
movb %cl, (%rax)
callq 0x22f90
movq 0x8(%rsp), %rdi
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, (%rax)
callq 0x22080
movq 0x8(%rsp), %rdi
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
callq 0x22500
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DS1307::setTime12(unsigned char, unsigned char, unsigned char, unsigned char)
void DS1307::setTime12(uint8_t hours, uint8_t minutes, uint8_t seconds, uint8_t ampm) {
    // write seconds first to reset divider chain and give
    // us 1 second to write remaining time info
    setSeconds(seconds);
    setMinutes(minutes);
    setHours12(hours, ampm);
}

// Assembly:
subq $0x18, %rsp
movb %r8b, %al
movq %rdi, 0x10(%rsp)
movb %sil, 0xf(%rsp)
movb %dl, 0xe(%rsp)
movb %cl, 0xd(%rsp)
movb %al, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movzbl 0xd(%rsp), %esi
callq 0x22410
movq (%rsp), %rdi
movzbl 0xe(%rsp), %esi
callq 0x226c0
movq (%rsp), %rdi
movb 0xf(%rsp), %al
movzbl %al, %esi
movzbl 0xc(%rsp), %edx
callq 0x22790
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DS1307::setTime24(unsigned char, unsigned char, unsigned char)
void DS1307::setTime24(uint8_t hours, uint8_t minutes, uint8_t seconds) {
    // write seconds first to reset divider chain and give
    // us 1 second to write remaining time info
    setSeconds(seconds);
    setMinutes(minutes);
    setHours24(hours);
}

// Assembly:
subq $0x18, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, 0x10(%rsp)
movb %dl, 0xf(%rsp)
movb %cl, 0xe(%rsp)
movb %al, 0xd(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movzbl 0xd(%rsp), %esi
callq 0x22410
movq (%rsp), %rdi
movzbl 0xe(%rsp), %esi
callq 0x226c0
movq (%rsp), %rdi
movzbl 0xf(%rsp), %esi
callq 0x23590
addq $0x18, %rsp
retq
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DS1307::setDateTime(DateTime)
void DS1307::setDateTime(DateTime dt) {
        setSeconds(dt.second());
        setMinutes(dt.minute());
        setHours24(dt.hour());
        setDay(dt.day());
        setMonth(dt.month());
        setYear(dt.year());
    }

// Assembly:
subq $0x18, %rsp
movl %esi, %eax
movl %eax, 0x12(%rsp)
shrq $0x20, %rsi
movw %si, %ax
movw %ax, 0x16(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x12(%rsp), %rdi
callq 0x230e0
movq (%rsp), %rdi
movzbl %al, %esi
callq 0x22410
leaq 0x12(%rsp), %rdi
callq 0x224f0
movq (%rsp), %rdi
movzbl %al, %esi
callq 0x226c0
leaq 0x12(%rsp), %rdi
callq 0x232d0
movq (%rsp), %rdi
movzbl %al, %esi
callq 0x23590
leaq 0x12(%rsp), %rdi
callq 0x229d0
movq (%rsp), %rdi
movzbl %al, %esi
callq 0x22ed0
leaq 0x12(%rsp), %rdi
callq 0x223b0
movq (%rsp), %rdi
movzbl %al, %esi
callq 0x22d50
leaq 0x12(%rsp), %rdi
callq 0x23430
movq (%rsp), %rdi
movzwl %ax, %esi
callq 0x22550
addq $0x18, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DateTime::DateTime(unsigned int)
DateTime::DateTime (uint32_t t) {
      t -= SECONDS_FROM_1970_TO_2000;    // bring to 2000 timestamp from 1970
    
        ss = t % 60;
        t /= 60;
        mm = t % 60;
        t /= 60;
        hh = t % 24;
        uint16_t days = t / 24;
        uint8_t leap;
        for (yOff = 0; ; ++yOff) {
            leap = yOff % 4 == 0;
            if (days < 365 + leap)
                break;
            days -= 365 + leap;
        }
        for (m = 1; ; ++m) {
            uint8_t daysPerMonth = pgm_read_byte(daysInMonth + m - 1);
            if (leap && m == 2)
                ++daysPerMonth;
            if (days < daysPerMonth)
                break;
            days -= daysPerMonth;
        }
        d = days + 1;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0xc(%rsp), %eax
subl $0x386d4380, %eax       # imm = 0x386D4380
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl $0x3c, %ecx
xorl %edx, %edx
divl %ecx
movq -0x18(%rsp), %rax
movb %dl, %cl
movb %cl, 0x5(%rax)
movl -0xc(%rsp), %eax
movl $0x3c, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl $0x3c, %ecx
xorl %edx, %edx
divl %ecx
movq -0x18(%rsp), %rax
movb %dl, %cl
movb %cl, 0x4(%rax)
movl -0xc(%rsp), %eax
movl $0x3c, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl $0x18, %ecx
xorl %edx, %edx
divl %ecx
movq -0x18(%rsp), %rax
movb %dl, %cl
movb %cl, 0x3(%rax)
movl -0xc(%rsp), %eax
movl $0x18, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq -0x18(%rsp), %rax
movw %cx, -0xe(%rsp)
movb $0x0, (%rax)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
andb $0x1, %al
movb %al, -0xf(%rsp)
movzwl -0xe(%rsp), %eax
movzbl -0xf(%rsp), %ecx
addl $0x16d, %ecx            # imm = 0x16D
cmpl %ecx, %eax
jge 0x30ef5
jmp 0x30f1a
movzbl -0xf(%rsp), %ecx
addl $0x16d, %ecx            # imm = 0x16D
movzwl -0xe(%rsp), %eax
subl %ecx, %eax
movw %ax, -0xe(%rsp)
movq -0x18(%rsp), %rax
movb (%rax), %cl
addb $0x1, %cl
movb %cl, (%rax)
jmp 0x30ec3
movq -0x18(%rsp), %rax
movb $0x1, 0x1(%rax)
movq -0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
movslq %eax, %rcx
leaq 0x1ad96(%rip), %rax     # 0x4bccc
movb -0x1(%rax,%rcx), %al
movb %al, -0x10(%rsp)
cmpb $0x0, -0xf(%rsp)
je 0x30f5d
movq -0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x2, %eax
jne 0x30f5d
movb -0x10(%rsp), %al
addb $0x1, %al
movb %al, -0x10(%rsp)
movzwl -0xe(%rsp), %eax
movzbl -0x10(%rsp), %ecx
cmpl %ecx, %eax
jge 0x30f6d
jmp 0x30f8e
movzbl -0x10(%rsp), %ecx
movzwl -0xe(%rsp), %eax
subl %ecx, %eax
movw %ax, -0xe(%rsp)
movq -0x18(%rsp), %rax
movb 0x1(%rax), %cl
addb $0x1, %cl
movb %cl, 0x1(%rax)
jmp 0x30f23
movq -0x18(%rsp), %rax
movzwl -0xe(%rsp), %ecx
addl $0x1, %ecx
movb %cl, 0x2(%rax)
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/DS1307/DS1307.cpp
// Function: DateTime::DateTime(unsigned short, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char)
DateTime::DateTime (uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t min, uint8_t sec) {
        if (year >= 2000)
            year -= 2000;
        yOff = year;
        m = month;
        d = day;
        hh = hour;
        mm = min;
        ss = sec;
    }

// Assembly:
movl %r8d, -0x28(%rsp)
movl %ecx, %eax
movl -0x28(%rsp), %ecx
movl %eax, -0x24(%rsp)
movl %edx, %eax
movl -0x24(%rsp), %edx
movl %eax, -0x20(%rsp)
movl %esi, %eax
movl -0x20(%rsp), %esi
movl %eax, -0x1c(%rsp)
movq %rdi, %r8
movl -0x1c(%rsp), %edi
movb %r9b, %al
movb 0x8(%rsp), %r9b
movq %r8, -0x8(%rsp)
movw %di, -0xa(%rsp)
movb %sil, -0xb(%rsp)
movb %dl, -0xc(%rsp)
movb %cl, -0xd(%rsp)
movb %al, -0xe(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movzwl -0xa(%rsp), %eax
cmpl $0x7d0, %eax            # imm = 0x7D0
jl 0x31012
movzwl -0xa(%rsp), %eax
subl $0x7d0, %eax            # imm = 0x7D0
movw %ax, -0xa(%rsp)
movq -0x18(%rsp), %rax
movw -0xa(%rsp), %cx
movb %cl, (%rax)
movb -0xb(%rsp), %cl
movb %cl, 0x1(%rax)
movb -0xc(%rsp), %cl
movb %cl, 0x2(%rax)
movb -0xd(%rsp), %cl
movb %cl, 0x3(%rax)
movb -0xe(%rsp), %cl
movb %cl, 0x4(%rax)
movb 0x8(%rsp), %cl
movb %cl, 0x5(%rax)
retq
nopw %cs:(%rax,%rax)