LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/softPwm.c
// Function: softPwmCreate
int softPwmCreate (int pin, int initialValue, int pwmRange)
{
  int res ;
  pthread_t myThread ;
  int *passPin ;

  if (pin >= MAX_PINS)
    return -1 ;

  if (range [pin] != 0)	// Already running on this pin
    return -1 ;

  if (pwmRange <= 0)
    return -1 ;

  passPin = malloc (sizeof (*passPin)) ;
  if (passPin == NULL)
    return -1 ;

  digitalWrite (pin, LOW) ;
  pinMode      (pin, OUTPUT) ;

  marks [pin] = initialValue ;
  range [pin] = pwmRange ;

  *passPin = pin ;
  newPin   = pin ;
  res      = pthread_create (&myThread, NULL, softPwmThread, (void *)passPin) ;

  if (res != 0)
    return res ;
  
  while (newPin != -1)
    delay (1) ;

  threads [pin] = myThread ;

  return res ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x3f, %edi
jle 0x22eee
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %r14d
movl %edi, %ebp
movslq %edi, %r13
leaq 0x24e63(%rip), %rax     # 0x47d60
movl (%rax,%r13,4), %eax
testl %edx, %edx
jle 0x22edd
testl %eax, %eax
jne 0x22edd
movl %esi, %r15d
movl $0x4, %edi
callq 0x1f7b0
testq %rax, %rax
je 0x22edd
movq %rax, %r12
movl %ebp, %edi
xorl %esi, %esi
callq 0x1fb30
movl %ebp, %edi
movl $0x1, %esi
callq 0x1f310
leaq 0x24f26(%rip), %rax     # 0x47e60
movl %r15d, (%rax,%r13,4)
leaq 0x24e1b(%rip), %rax     # 0x47d60
movl %r14d, (%rax,%r13,4)
movl %ebp, (%r12)
movl %ebp, 0x2465d(%rip)     # 0x475b0
leaq 0x44(%rip), %rdx        # 0x22f9e
movq %rsp, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x1fa70
movl %eax, %ebx
testl %eax, %eax
jne 0x22edd
jmp 0x22f7d
movl $0x1, %edi
callq 0x1f460
movl 0x2462d(%rip), %eax     # 0x475b0
cmpl $-0x1, %eax
jne 0x22f73
movq (%rsp), %rax
leaq 0x24fcd(%rip), %rcx     # 0x47f60
movq %rax, (%rcx,%r13,8)
xorl %ebx, %ebx
jmp 0x22edd
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/softPwm.c
// Function: softPwmThread
static void *softPwmThread (void *arg)
{
  int pin, mark, space ;
  struct sched_param param ;

  param.sched_priority = sched_get_priority_max (SCHED_RR) ;
  pthread_setschedparam (pthread_self (), SCHED_RR, &param) ;

  pin = *((int *)arg) ;
  free (arg) ;

  pin    = newPin ;
  newPin = -1 ;

  piHiPri (90) ;

  for (;;)
  {
    mark  = marks [pin] ;
    space = range [pin] - mark ;

    if (mark != 0)
      digitalWrite (pin, HIGH) ;
    delayMicroseconds (mark * 100) ;

    if (space != 0)
      digitalWrite (pin, LOW) ;
    delayMicroseconds (space * 100) ;
  }

  return NULL ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x2, %edi
callq 0x1f570
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
callq 0x1f500
movq %rax, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x1f360
movq %rbx, %rdi
callq 0x1f6e0
movslq 0x245cd(%rip), %rbx     # 0x475b0
movl $0xffffffff, 0x245c3(%rip) # imm = 0xFFFFFFFF
movl $0x5a, %edi
callq 0x1f0f0
leaq 0x24e62(%rip), %r14     # 0x47e60
leaq 0x24d5b(%rip), %r15     # 0x47d60
movl (%r14,%rbx,4), %ebp
movl (%r15,%rbx,4), %r12d
testl %ebp, %ebp
je 0x2301d
movl %ebx, %edi
movl $0x1, %esi
callq 0x1fb30
imull $0x64, %ebp, %edi
callq 0x1f2f0
cmpl %ebp, %r12d
je 0x23033
movl %ebx, %edi
xorl %esi, %esi
callq 0x1fb30
subl %ebp, %r12d
imull $0x64, %r12d, %edi
callq 0x1f2f0
jmp 0x23005
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/softPwm.c
// Function: softPwmStop
void softPwmStop (int pin)
{
  if (pin < MAX_PINS)
  {
    if (range [pin] != 0)
    {
      pthread_cancel (threads [pin]) ;
      pthread_join   (threads [pin], NULL) ;
      range [pin] = 0 ;
      digitalWrite (pin, LOW) ;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x3f, %edi
jg 0x23098
movl %edi, %ebx
movslq %edi, %r14
leaq 0x24d06(%rip), %r15     # 0x47d60
cmpl $0x0, (%r15,%r14,4)
je 0x23098
leaq 0x24ef8(%rip), %r12     # 0x47f60
movq (%r12,%r14,8), %rdi
callq 0x1f810
movq (%r12,%r14,8), %rdi
xorl %esi, %esi
callq 0x1f510
movl $0x0, (%r15,%r14,4)
movl %ebx, %edi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1fb30
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/softTone.c
// Function: softToneCreate
int softToneCreate (int pin)
{
  int res ;
  pthread_t myThread ;

  pinMode      (pin, OUTPUT) ;
  digitalWrite (pin, LOW) ;

  if (threads [pin] != 0)
    return -1 ;

  freqs [pin] = 0 ;

  newPin = pin ;
  res    = pthread_create (&myThread, NULL, softToneThread, NULL) ;

  while (newPin != -1)
    delay (1) ;

  threads [pin] = myThread ;

  return res ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movl $0x1, %esi
callq 0x1f310
movl %ebx, %edi
xorl %esi, %esi
callq 0x1fb30
movslq %ebx, %r14
leaq 0x25175(%rip), %r15     # 0x48260
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq $0x0, (%r15,%r14,8)
jne 0x23142
leaq 0x25062(%rip), %rax     # 0x48160
movl $0x0, (%rax,%r14,4)
movl %r14d, 0x244a7(%rip)    # 0x475b4
leaq 0x3a(%rip), %rdx        # 0x2314e
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1fa70
movl %eax, %ebx
cmpl $-0x1, 0x24489(%rip)    # 0x475b4
je 0x23139
movl $0x1, %edi
callq 0x1f460
jmp 0x23124
movq 0x8(%rsp), %rax
movq %rax, (%r15,%r14,8)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/softTone.c
// Function: softToneThread
static PI_THREAD (softToneThread)
{
  int pin, freq, halfPeriod ;
  struct sched_param param ;

  param.sched_priority = sched_get_priority_max (SCHED_RR) ;
  pthread_setschedparam (pthread_self (), SCHED_RR, &param) ;

  pin    = newPin ;
  newPin = -1 ;

  piHiPri (50) ;

  for (;;)
  {
    freq = freqs [pin] ;
    if (freq == 0)
      delay (1) ;
    else
    {
      halfPeriod = 500000 / freq ;

      digitalWrite (pin, HIGH) ;
      delayMicroseconds (halfPeriod) ;

      digitalWrite (pin, LOW) ;
      delayMicroseconds (halfPeriod) ;
    }
  }

  return NULL ;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x2, %edi
callq 0x1f570
leaq 0xc(%rsp), %rbx
movl %eax, (%rbx)
callq 0x1f500
movq %rax, %rdi
movl $0x2, %esi
movq %rbx, %rdx
callq 0x1f360
movslq 0x24431(%rip), %rbx     # 0x475b4
movl $0xffffffff, 0x24427(%rip) # imm = 0xFFFFFFFF
movl $0x32, %edi
callq 0x1f0f0
leaq 0x24fc2(%rip), %r14     # 0x48160
movl (%r14,%rbx,4), %ecx
testl %ecx, %ecx
je 0x231d6
movl $0x7a120, %eax          # imm = 0x7A120
xorl %edx, %edx
idivl %ecx
movl %eax, %ebp
movl %ebx, %edi
movl $0x1, %esi
callq 0x1fb30
movl %ebp, %edi
callq 0x1f2f0
movl %ebx, %edi
xorl %esi, %esi
callq 0x1fb30
movl %ebp, %edi
callq 0x1f2f0
jmp 0x2319e
movl $0x1, %edi
callq 0x1f460
jmp 0x2319e
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/softTone.c
// Function: softToneStop
void softToneStop (int pin)
{
  if (threads [pin] != 0)
  {
    pthread_cancel (threads [pin]) ;
    pthread_join   (threads [pin], NULL) ;
    threads [pin] = 0 ;
    digitalWrite (pin, LOW) ;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq %edi, %rbx
leaq 0x25070(%rip), %r14     # 0x48260
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x23221
callq 0x1f810
movq (%r14,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1f510
movq $0x0, (%r14,%rbx,8)
movl %ebx, %edi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1fb30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: wiringPiFailure
int wiringPiFailure (int fatal, const char *message, ...)
{
  va_list argp ;
  char buffer [1024] ;

  if (!fatal && wiringPiReturnCodes)
    return -1 ;

  va_start (argp, message) ;
    vsnprintf (buffer, 1023, message, argp) ;
  va_end (argp) ;

  fprintf (stderr, "%s", buffer) ;
  exit (EXIT_FAILURE) ;

  return 0 ;
}

// Assembly:
pushq %rbx
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rsi, %r10
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x23286
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testl %edi, %edi
jne 0x232a4
movq 0x23d1f(%rip), %rax     # 0x46fb0
cmpl $0x0, (%rax)
je 0x232a4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbx
retq
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x4e0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %rbx
movl $0x3ff, %esi            # imm = 0x3FF
movq %rbx, %rdi
movq %r10, %rdx
callq 0x1f340
movq 0x23cb0(%rip), %rax     # 0x46f98
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1f670
movl $0x1, %edi
callq 0x1f700
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: piGpioLayoutOops
static void piGpioLayoutOops (const char *why)
{
  fprintf (stderr, "Oops: Unable to determine board revision from /proc/cpuinfo\n") ;
  fprintf (stderr, " -> %s\n", why) ;
  fprintf (stderr, " ->  You'd best google the error to find out why.\n") ;
//fprintf (stderr, " ->  http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
  exit (EXIT_FAILURE) ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x23a73(%rip), %r14     # 0x46f98
movq (%r14), %rcx
leaq 0x128b6(%rip), %rdi     # 0x35de5
movl $0x3c, %esi
movl $0x1, %edx
callq 0x1faf0
movq (%r14), %rdi
leaq 0x128da(%rip), %rsi     # 0x35e22
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1f880
movq (%r14), %rcx
leaq 0x128ce(%rip), %rdi     # 0x35e2a
movl $0x32, %esi
movl $0x1, %edx
callq 0x1faf0
movl $0x1, %edi
callq 0x1f700
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: setPadDrive
void setPadDrive (int group, int value)
{
  uint32_t wrVal ;

  if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
  {
    if ((group < 0) || (group > 2))
      return ;

    wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
    *(pads + group + 11) = wrVal ;

    if (wiringPiDebug)
    {
      printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
      printf ("Read : %08X\n", *(pads + group + 11)) ;
    }
  }
}

// Assembly:
pushq %rbx
movl 0x23b87(%rip), %eax     # 0x47774
cmpl $0x3, %eax
ja 0x23c4c
cmpl $0x2, %eax
je 0x23c4c
movl %esi, %edx
movl %edi, %esi
cmpl $0x2, %edi
ja 0x23c4c
movl %edx, %ecx
andl $0x7, %ecx
orl $0x5a000018, %ecx       # imm = 0x5A000018
movq 0x24876(%rip), %rax     # 0x48488
movl %esi, %ebx
movl %ecx, 0x2c(%rax,%rbx,4)
movq 0x23341(%rip), %rax     # 0x46f60
cmpl $0x0, (%rax)
je 0x23c4c
leaq 0x11d51(%rip), %rdi     # 0x3597c
xorl %eax, %eax
callq 0x1f050
movq 0x2484f(%rip), %rax     # 0x48488
movl 0x2c(%rax,%rbx,4), %esi
leaq 0x11d62(%rip), %rdi     # 0x359a6
xorl %eax, %eax
popq %rbx
jmp 0x1f050
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: getAlt
int getAlt (int pin)
{
  int fSel, shift, alt ;

  pin &= 63 ;

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

  fSel    = gpioToGPFSEL [pin] ;
  shift   = gpioToShift  [pin] ;

  alt = (*(gpio + fSel) >> shift) & 7 ;

  return alt ;
}

// Assembly:
andl $0x3f, %edi
movl 0x23b1d(%rip), %ecx     # 0x47774
testl %ecx, %ecx
je 0x23c70
cmpl $0x1, %ecx
je 0x23c7f
xorl %eax, %eax
cmpl $0x3, %ecx
jne 0x23ca6
leaq 0x24812(%rip), %rax     # 0x48480
jmp 0x23c77
leaq 0x24801(%rip), %rax     # 0x48478
movq (%rax), %rax
movl %edi, %ecx
movl (%rax,%rcx,4), %edi
movslq %edi, %rax
leaq 0x115a7(%rip), %rcx     # 0x35230
movzbl (%rax,%rcx), %edx
leaq 0x115dc(%rip), %rcx     # 0x35270
movb (%rax,%rcx), %cl
movq 0x247f2(%rip), %rax     # 0x48490
movl (%rax,%rdx,4), %eax
shrl %cl, %eax
andl $0x7, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: delayMicroseconds
void delayMicroseconds (unsigned int howLong)
{
  struct timespec sleeper ;
  unsigned int uSecs = howLong % 1000000 ;
  unsigned int wSecs = howLong / 1000000 ;

  /**/ if (howLong ==   0)
    return ;
  else if (howLong  < 100)
    delayMicrosecondsHard (howLong) ;
  else
  {
    sleeper.tv_sec  = wSecs ;
    sleeper.tv_nsec = (long)(uSecs * 1000L) ;
    nanosleep (&sleeper, NULL) ;
  }
}

// Assembly:
testl %edi, %edi
je 0x23d55
cmpl $0x63, %edi
jbe 0x1f240
subq $0x18, %rsp
movl %edi, %eax
imulq $0x431bde83, %rax, %rax # imm = 0x431BDE83
shrq $0x32, %rax
imull $0xf4240, %eax, %ecx    # imm = 0xF4240
subl %ecx, %edi
movl %eax, %ecx
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
imull $0x3e8, %edi, %ecx      # imm = 0x3E8
movq %rcx, 0x8(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x1f160
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: pwmSetClock
void pwmSetClock (int divisor)
{
  uint32_t pwm_control ;

  if (piGpioBase == GPIO_PERI_BASE_2711)
  {
    divisor = 540*divisor/192;
  }
  divisor &= 4095 ;

  if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
  {
    if (wiringPiDebug)
      printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;

    pwm_control = *(pwm + PWM_CONTROL) ;		// preserve PWM_CONTROL

// We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY
// stays high.

    *(pwm + PWM_CONTROL) = 0 ;				// Stop PWM

// Stop PWM clock before changing divisor. The delay after this does need to
// this big (95uS occasionally fails, 100uS OK), it's almost as though the BUSY
// flag is not working properly in balanced mode. Without the delay when DIV is
// adjusted the clock sometimes switches to very slow, once slow further DIV
// adjustments do nothing and it's difficult to get out of this mode.

    *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;	// Stop PWM Clock
      delayMicroseconds (110) ;			// prevents clock going sloooow

    while ((*(clk + PWMCLK_CNTL) & 0x80) != 0)	// Wait for clock to be !BUSY
      delayMicroseconds (1) ;

    *(clk + PWMCLK_DIV)  = BCM_PASSWORD | (divisor << 12) ;

    *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ;	// Start PWM clock
    *(pwm + PWM_CONTROL) = pwm_control ;		// restore PWM_CONTROL

    if (wiringPiDebug)
      printf ("Set     to: %d. Now    : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movl 0x2473a(%rip), %eax     # 0x484a0
cmpl $0xfe000000, %eax       # imm = 0xFE000000
jne 0x23d89
imull $0x21c, %ebx, %eax      # imm = 0x21C
cltq
imulq $0x2aaaaaab, %rax, %rbx # imm = 0x2AAAAAAB
movq %rbx, %rax
shrq $0x3f, %rax
sarq $0x25, %rbx
addl %eax, %ebx
movl 0x239e5(%rip), %eax     # 0x47774
cmpl $0x3, %eax
ja 0x23e67
cmpl $0x2, %eax
je 0x23e67
andl $0xfff, %ebx            # imm = 0xFFF
movq 0x231b2(%rip), %r14     # 0x46f60
cmpl $0x0, (%r14)
je 0x23dd1
movq 0x246ed(%rip), %rax     # 0x484a8
movl 0xa4(%rax), %edx
leaq 0x11beb(%rip), %rdi     # 0x359b3
movl %ebx, %esi
xorl %eax, %eax
callq 0x1f050
movq 0x246c0(%rip), %rax     # 0x48498
movl (%rax), %ebp
movl $0x0, (%rax)
movq 0x246c1(%rip), %rax     # 0x484a8
movl $0x5a000001, 0xa0(%rax) # imm = 0x5A000001
movq %rsp, %rdi
movq $0x0, (%rdi)
movq $0x1adb0, 0x8(%rdi)     # imm = 0x1ADB0
xorl %esi, %esi
callq 0x1f160
movq 0x24697(%rip), %rax     # 0x484a8
movl 0xa0(%rax), %ecx
testb %cl, %cl
jns 0x23e27
movl $0x1, %edi
callq 0x1f240
jmp 0x23e0a
movl %ebx, %ecx
shll $0xc, %ecx
orl $0x5a000000, %ecx       # imm = 0x5A000000
movl %ecx, 0xa4(%rax)
movl $0x5a000011, 0xa0(%rax) # imm = 0x5A000011
movq 0x2464f(%rip), %rcx     # 0x48498
movl %ebp, (%rcx)
cmpl $0x0, (%r14)
je 0x23e67
movl 0xa4(%rax), %edx
leaq 0x11b76(%rip), %rdi     # 0x359d4
movl %ebx, %esi
xorl %eax, %eax
callq 0x1f050
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: gpioClockSet
void gpioClockSet (int pin, int freq)
{
  int divi, divr, divf ;

  pin &= 63 ;

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

  divi = 19200000 / freq ;
  divr = 19200000 % freq ;
  divf = (int)((double)divr * 4096.0 / 19200000.0) ;

  if (divi > 4095)
    divi = 4095 ;

  *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | GPIO_CLOCK_SOURCE ;		// Stop GPIO Clock
  while ((*(clk + gpioToClkCon [pin]) & 0x80) != 0)				// ... and wait
    ;

  *(clk + gpioToClkDiv [pin]) = BCM_PASSWORD | (divi << 12) | divf ;		// Set dividers
  *(clk + gpioToClkCon [pin]) = BCM_PASSWORD | 0x10 | GPIO_CLOCK_SOURCE ;	// Start Clock
}

// Assembly:
andl $0x3f, %edi
movl 0x238fb(%rip), %eax     # 0x47774
testl %eax, %eax
je 0x23e94
cmpl $0x1, %eax
je 0x23ea3
cmpl $0x3, %eax
jne 0x23f14
leaq 0x245ee(%rip), %rax     # 0x48480
jmp 0x23e9b
leaq 0x245dd(%rip), %rax     # 0x48478
movq (%rax), %rax
movl %edi, %ecx
movl (%rax,%rcx,4), %edi
movl $0x124f800, %eax        # imm = 0x124F800
xorl %edx, %edx
idivl %esi
cvtsi2sd %edx, %xmm0
mulsd 0x11300(%rip), %xmm0    # 0x351b8
divsd 0x11300(%rip), %xmm0    # 0x351c0
cvttsd2si %xmm0, %r8d
movq 0x245dc(%rip), %rcx     # 0x484a8
movslq %edi, %rsi
leaq 0x113da(%rip), %rdx     # 0x352b0
movzbl (%rsi,%rdx), %edx
movl $0x5a000001, (%rcx,%rdx,4) # imm = 0x5A000001
movl (%rcx,%rdx,4), %edi
testb %dil, %dil
js 0x23ee1
movl $0xfff, %edi            # imm = 0xFFF
cmpl %edi, %eax
cmovll %eax, %edi
shll $0xc, %edi
orl %r8d, %edi
orl $0x5a000000, %edi       # imm = 0x5A000000
leaq 0x113ea(%rip), %rax     # 0x352f0
movzbl (%rsi,%rax), %eax
movl %edi, (%rcx,%rax,4)
movl $0x5a000011, (%rcx,%rdx,4) # imm = 0x5A000011
retq
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: wiringPiNewNode
struct wiringPiNodeStruct *wiringPiNewNode (int pinBase, int numPins)
{
  int    pin ;
  struct wiringPiNodeStruct *node ;

// Minimum pin base is 64

  if (pinBase < 64)
    (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: pinBase of %d is < 64\n", pinBase) ;

// Check all pins in-case there is overlap:

  for (pin = pinBase ; pin < (pinBase + numPins) ; ++pin)
    if (wiringPiFindNode (pin) != NULL)
      (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: Pin %d overlaps with existing definition\n", pin) ;

  node = (struct wiringPiNodeStruct *)calloc (sizeof (struct wiringPiNodeStruct), 1) ;	// calloc zeros
  if (node == NULL)
    (void)wiringPiFailure (WPI_FATAL, "wiringPiNewNode: Unable to allocate memory: %s\n", strerror (errno)) ;

  node->pinBase          = pinBase ;
  node->pinMax           = pinBase + numPins - 1 ;
  node->pinMode          = pinModeDummy ;
  node->pullUpDnControl  = pullUpDnControlDummy ;
  node->digitalRead      = digitalReadDummy ;
//node->digitalRead8     = digitalRead8Dummy ;
  node->digitalWrite     = digitalWriteDummy ;
//node->digitalWrite8    = digitalWrite8Dummy ;
  node->pwmWrite         = pwmWriteDummy ;
  node->analogRead       = analogReadDummy ;
  node->analogWrite      = analogWriteDummy ;
  node->next             = wiringPiNodes ;
  wiringPiNodes          = node ;

  return node ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movl %edi, %ebx
cmpl $0x3f, %edi
jg 0x23f5d
leaq 0x11aa6(%rip), %rsi     # 0x359f5
movl $0x1, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1f270
leal (%r14,%rbx), %r15d
testl %r14d, %r14d
jle 0x23fb6
movq 0x2304b(%rip), %r12     # 0x46fb8
movq (%r12), %rax
leaq 0x11aa5(%rip), %r14     # 0x35a1d
movl %ebx, %ebp
testq %rax, %rax
je 0x23f96
movq %rax, %rcx
cmpl %ebp, (%rcx)
jg 0x23f8b
cmpl %ebp, 0x4(%rcx)
jge 0x23f9a
movq 0x58(%rcx), %rcx
testq %rcx, %rcx
jne 0x23f82
jmp 0x23faf
xorl %eax, %eax
jmp 0x23faf
movl $0x1, %edi
movq %r14, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1f270
movq (%r12), %rax
incl %ebp
cmpl %r15d, %ebp
jl 0x23f7a
movl $0x60, %edi
movl $0x1, %esi
callq 0x1f350
movq %rax, %r14
testq %rax, %rax
jne 0x23fef
callq 0x1f040
movl (%rax), %edi
callq 0x1f190
leaq 0x11a78(%rip), %rsi     # 0x35a58
movl $0x1, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1f270
movl %ebx, (%r14)
decl %r15d
movl %r15d, 0x4(%r14)
leaq 0x63(%rip), %rax        # 0x24063
movq %rax, 0x20(%r14)
leaq 0x59(%rip), %rax        # 0x24064
movq %rax, 0x28(%r14)
leaq 0x4f(%rip), %rax        # 0x24065
movq %rax, 0x30(%r14)
leaq 0x47(%rip), %rax        # 0x24068
movq %rax, 0x38(%r14)
leaq 0x3d(%rip), %rax        # 0x24069
movq %rax, 0x40(%r14)
leaq 0x33(%rip), %rax        # 0x2406a
movq %rax, 0x48(%r14)
leaq 0x2b(%rip), %rax        # 0x2406d
movq %rax, 0x50(%r14)
movq 0x22f6b(%rip), %rax     # 0x46fb8
movq (%rax), %rcx
movq %rcx, 0x58(%r14)
movq %r14, (%rax)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: pinModeAlt
void pinModeAlt (int pin, int mode)
{
  int fSel, shift ;

  setupCheck ("pinModeAlt") ;

  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 ;

    fSel  = gpioToGPFSEL [pin] ;
    shift = gpioToShift  [pin] ;

    *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | ((mode & 0x7) << shift) ;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
leaq 0x11a0c(%rip), %rdi     # 0x35a88
callq 0x240ee
cmpl $0x3f, %ebp
ja 0x240e7
movl 0x236e8(%rip), %eax     # 0x47774
testl %eax, %eax
je 0x240a3
cmpl $0x1, %eax
je 0x240b2
cmpl $0x3, %eax
jne 0x240e7
leaq 0x243df(%rip), %rax     # 0x48480
jmp 0x240aa
leaq 0x243ce(%rip), %rax     # 0x48478
movq (%rax), %rax
movl %ebp, %ecx
movl (%rax,%rcx,4), %ebp
movslq %ebp, %rax
leaq 0x11174(%rip), %rdx     # 0x35230
leaq 0x111ad(%rip), %rcx     # 0x35270
movb (%rax,%rcx), %cl
movl $0x7, %esi
shll %cl, %esi
movzbl (%rax,%rdx), %eax
movq 0x243b8(%rip), %rdx     # 0x48490
notl %esi
andl $0x7, %ebx
shll %cl, %ebx
andl (%rdx,%rax,4), %esi
orl %esi, %ebx
movl %ebx, (%rdx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: digitalRead
int digitalRead (int pin)
{
  char c ;
  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)
	return LOW ;

      lseek  (sysFds [pin], 0L, SEEK_SET) ;
      read   (sysFds [pin], &c, 1) ;
      return (c == '0') ? LOW : HIGH ;
    }
    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 LOW ;

    if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
      return HIGH ;
    else
      return LOW ;
  }
  else
  {
    if ((node = wiringPiFindNode (pin)) == NULL)
      return LOW ;
    return node->digitalRead (node, pin) ;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %esi
cmpl $0x3f, %edi
ja 0x244eb
movl 0x232ae(%rip), %ecx     # 0x47774
xorl %eax, %eax
cmpq $0x3, %rcx
ja 0x24586
leaq 0x10d13(%rip), %rdx     # 0x351ec
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x23f8f(%rip), %rax     # 0x48478
jmp 0x2455e
movq 0x22ac6(%rip), %rax     # 0x46fb8
movq (%rax), %rdi
xorl %eax, %eax
testq %rdi, %rdi
je 0x24586
cmpl %esi, (%rdi)
jg 0x24509
cmpl %esi, 0x4(%rdi)
jge 0x2450f
movq 0x58(%rdi), %rdi
jmp 0x244f7
movq 0x30(%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movl %esi, %ebx
leaq 0x2325b(%rip), %r14     # 0x47780
movl (%r14,%rbx,4), %edi
cmpl $-0x1, %edi
je 0x24586
xorl %esi, %esi
xorl %edx, %edx
callq 0x1fac0
movl (%r14,%rbx,4), %edi
leaq 0x7(%rsp), %rbx
movl $0x1, %edx
movq %rbx, %rsi
callq 0x1f890
xorl %eax, %eax
cmpb $0x30, (%rbx)
setne %al
jmp 0x24586
leaq 0x23f22(%rip), %rax     # 0x48480
movq (%rax), %rax
movl %esi, %ecx
movl (%rax,%rcx,4), %esi
movq 0x23f23(%rip), %rax     # 0x48490
movslq %esi, %rcx
leaq 0x10df9(%rip), %rdx     # 0x35370
movzbl (%rcx,%rdx), %edx
movl (%rax,%rdx,4), %edx
xorl %eax, %eax
btl %ecx, %edx
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl %esi, %edx
movl %edi, %ecx
cmpl $0x3f, %edi
ja 0x245c0
movl 0x231d7(%rip), %eax     # 0x47774
cmpq $0x3, %rax
ja 0x2463f
leaq 0x10c4e(%rip), %rsi     # 0x351fc
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
leaq 0x23eba(%rip), %rax     # 0x48478
jmp 0x2460b
movq 0x229f1(%rip), %rax     # 0x46fb8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2463f
cmpl %ecx, (%rdi)
jg 0x245d8
cmpl %ecx, 0x4(%rdi)
jge 0x245de
movq 0x58(%rdi), %rdi
jmp 0x245ca
movq 0x38(%rdi), %rax
movl %ecx, %esi
jmpq *%rax
movl %ecx, %eax
leaq 0x23191(%rip), %rcx     # 0x47780
movl (%rcx,%rax,4), %edi
cmpl $-0x1, %edi
je 0x2463f
testl %edx, %edx
je 0x24640
leaq 0x114c6(%rip), %rsi     # 0x35ac8
jmp 0x24647
leaq 0x23e75(%rip), %rax     # 0x48480
movq (%rax), %rax
movl %ecx, %ecx
movl (%rax,%rcx,4), %ecx
movl $0x1, %eax
shll %cl, %eax
movq 0x23e6f(%rip), %rsi     # 0x48490
movslq %ecx, %rcx
testl %edx, %edx
je 0x24631
leaq 0x10dc1(%rip), %rdx     # 0x353f0
jmp 0x24638
leaq 0x10d78(%rip), %rdx     # 0x353b0
movzbl (%rcx,%rdx), %ecx
movl %eax, (%rsi,%rcx,4)
retq
leaq 0x1147e(%rip), %rsi     # 0x35ac5
movl $0x2, %edx
jmp 0x1f1a0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
leaq 0x1146c(%rip), %rdi     # 0x35acb
callq 0x240ee
cmpl $0x3f, %ebp
ja 0x24686
movl 0x23105(%rip), %eax     # 0x47774
testl %eax, %eax
je 0x246a4
cmpl $0x1, %eax
je 0x246b3
cmpl $0x3, %eax
jne 0x246d7
leaq 0x23dfc(%rip), %rax     # 0x48480
jmp 0x246ab
movq 0x2292b(%rip), %rax     # 0x46fb8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x246d7
cmpl %ebp, (%rdi)
jg 0x2469e
cmpl %ebp, 0x4(%rdi)
jge 0x246de
movq 0x58(%rdi), %rdi
jmp 0x24690
leaq 0x23dcd(%rip), %rax     # 0x48478
movq (%rax), %rax
movl %ebp, %ecx
movl (%rax,%rcx,4), %ebp
leaq 0x11411(%rip), %rdi     # 0x35acb
callq 0x24362
movq 0x23dd2(%rip), %rax     # 0x48498
movslq %ebp, %rcx
leaq 0x10de0(%rip), %rdx     # 0x354b0
movzbl (%rcx,%rdx), %ecx
movl %ebx, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x40(%rdi), %rax
movl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl %edi, %esi
movq 0x228c1(%rip), %rax     # 0x46fb8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2470e
cmpl %esi, (%rdi)
jg 0x24708
cmpl %esi, 0x4(%rdi)
jge 0x24711
movq 0x58(%rdi), %rdi
jmp 0x246fa
xorl %eax, %eax
retq
movq 0x48(%rdi), %rax
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl %esi, %edx
movl %edi, %esi
movq 0x22896(%rip), %rax     # 0x46fb8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x24739
cmpl %esi, (%rdi)
jg 0x24733
cmpl %esi, 0x4(%rdi)
jge 0x2473a
movq 0x58(%rdi), %rdi
jmp 0x24725
retq
movq 0x50(%rdi), %rax
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
leaq 0x11386(%rip), %rdi     # 0x35ad4
callq 0x240ee
testl %ebp, %ebp
je 0x24772
movl $0x927c0, %eax          # imm = 0x927C0
xorl %edx, %edx
idivl %ebp
movl %eax, %edi
callq 0x1f330
movl %ebp, %esi
shrl $0x1f, %esi
addl %ebp, %esi
sarl %esi
jmp 0x24774
xorl %esi, %esi
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1f1d0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
cmpl $0x2, 0x22fe6(%rip)     # 0x47774
jne 0x247b9
movl $0x1, %ebp
xorl %r14d, %r14d
movq 0x23cd9(%rip), %rax     # 0x48478
movl (%rax,%r14,4), %edi
movl %ebp, %esi
andl %ebx, %esi
callq 0x1fb30
addl %ebp, %ebp
incq %r14
cmpq $0x8, %r14
jne 0x24798
jmp 0x2480c
xorl %eax, %eax
movl $0x1, %edx
movq 0x23cb1(%rip), %rsi     # 0x48478
xorl %r9d, %r9d
xorl %edi, %edi
xorl %r8d, %r8d
movl %edx, %r10d
movb (%rsi,%r9,4), %cl
movl $0x1, %r11d
shll %cl, %r11d
andl %ebx, %r10d
testl %r10d, %r10d
cmovnel %r11d, %r10d
cmovnel %eax, %r11d
orl %r10d, %r8d
orl %r11d, %edi
addl %edx, %edx
incq %r9
cmpq $0x8, %r9
jne 0x247cf
movq 0x23c8b(%rip), %rax     # 0x48490
movl %edi, 0x28(%rax)
movl %r8d, 0x1c(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, 0x22f58(%rip)     # 0x47774
jne 0x24842
xorl %r14d, %r14d
xorl %ebx, %ebx
movq 0x23c4e(%rip), %rax     # 0x48478
movl (%rax,%r14,4), %edi
callq 0x1f1c0
addl %ebx, %ebx
orl %eax, %ebx
incq %r14
cmpq $0x8, %r14
jne 0x24823
jmp 0x2486f
movq 0x23c47(%rip), %rax     # 0x48490
movl 0x34(%rax), %eax
xorl %ecx, %ecx
movq 0x23c23(%rip), %rdx     # 0x48478
xorl %ebx, %ebx
movl (%rdx,%rcx,4), %esi
xorl %edi, %edi
btl %esi, %eax
setb %dil
leal (%rdi,%rbx,2), %ebx
incq %rcx
cmpq $0x8, %rcx
jne 0x24857
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
cmpl $0x2, 0x22eee(%rip)     # 0x47774
jne 0x248ab
movl $0x1, %r14d
movl $0x14, %ebp
movl %r14d, %esi
andl %ebx, %esi
movl %ebp, %edi
callq 0x1fb30
addl %r14d, %r14d
incl %ebp
cmpl $0x1c, %ebp
jne 0x24893
jmp 0x248c6
movzbl %bl, %eax
shll $0x14, %eax
movl %eax, %ecx
xorl $0xff00000, %ecx        # imm = 0xFF00000
movq 0x23bd0(%rip), %rdx     # 0x48490
movl %ecx, 0x28(%rdx)
movl %eax, 0x1c(%rdx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x2, 0x22e9f(%rip)     # 0x47774
jne 0x248f2
movl $0x14, %ebp
xorl %ebx, %ebx
movl %ebp, %edi
callq 0x1f1c0
addl %ebx, %ebx
orl %eax, %ebx
incl %ebp
cmpl $0x1c, %ebp
jne 0x248de
jmp 0x24902
movq 0x23b97(%rip), %rax     # 0x48490
movl 0x34(%rax), %eax
shrl $0x14, %eax
movzbl %al, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl %esi, %edx
movl 0x22e61(%rip), %eax     # 0x47774
testl %eax, %eax
je 0x24925
cmpl $0x3, %eax
jne 0x24935
leaq 0x23b5d(%rip), %rax     # 0x48480
jmp 0x2492c
leaq 0x23b4c(%rip), %rax     # 0x48478
movq (%rax), %rax
movslq %edi, %rcx
movl (%rax,%rcx,4), %edi
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movslq %edi, %rax
leaq 0x22e3b(%rip), %rcx     # 0x47780
movl (%rcx,%rax,4), %ebx
cmpl $-0x1, %ebx
je 0x24988
leaq 0x10(%rsp), %rdi
movl %ebx, (%rdi)
movw $0xa, 0x4(%rdi)
movl $0x1, %esi
callq 0x1f8c0
movl %eax, %ebp
testl %eax, %eax
jle 0x2498d
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1fac0
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movl %ebx, %edi
callq 0x1f890
jmp 0x2498d
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movl $0x37, %edi
callq 0x1f0f0
movslq 0x22c15(%rip), %rbx     # 0x47880
movl $0xffffffff, 0x22c0b(%rip) # imm = 0xFFFFFFFF
leaq 0x23844(%rip), %r14     # 0x484c0
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1f100
testl %eax, %eax
jle 0x24c7c
callq *(%r14,%rbx,8)
jmp 0x24c7c
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1fa10
movq 0x21d15(%rip), %rax     # 0x46f60
cmpl $0x0, (%rax)
je 0x2525c
leaq 0x10cd5(%rip), %rdi     # 0x35f2c
callq 0x1f900
movl $0x1, 0x2250e(%rip)     # 0x47774
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1fa10
movq 0x21ce9(%rip), %rax     # 0x46f60
cmpl $0x0, (%rax)
je 0x25288
leaq 0x10ccc(%rip), %rdi     # 0x35f4f
callq 0x1f900
movl $0x3, 0x224e2(%rip)     # 0x47774
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpb $0x0, 0x2345b(%rip)     # 0x486f8
jne 0x25419
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movb $0x1, 0x23440(%rip)     # 0x486f8
leaq 0x1096d(%rip), %rdi     # 0x35c2c
callq 0x1f710
testq %rax, %rax
je 0x252d6
movq 0x21c90(%rip), %rax     # 0x46f60
movl $0x1, (%rax)
leaq 0x1095e(%rip), %rdi     # 0x35c3b
callq 0x1f710
testq %rax, %rax
je 0x252f4
movq 0x21cc2(%rip), %rax     # 0x46fb0
movl $0x1, (%rax)
movq 0x21c65(%rip), %rax     # 0x46f60
cmpl $0x0, (%rax)
je 0x2530c
leaq 0x10c6b(%rip), %rdi     # 0x35f72
callq 0x1f900
callq 0x1fb20
cmpl $0x1, %eax
leaq 0x22575(%rip), %rax     # 0x47890
leaq 0x2276e(%rip), %rcx     # 0x47a90
cmoveq %rax, %rcx
leaq 0x22663(%rip), %rax     # 0x47990
leaq 0x2285c(%rip), %rdx     # 0x47b90
cmoveq %rax, %rdx
movq %rcx, 0x23139(%rip)     # 0x48478
movq %rdx, 0x2313a(%rip)     # 0x48480
leaq 0x22433(%rip), %r12     # 0x47780
leaq 0x10897(%rip), %rbx     # 0x35beb
leaq 0x10(%rsp), %r14
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1f090
movq %r14, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x1f3c0
movl %eax, (%r12)
incq %r15
addq $0x4, %r12
cmpq $0x40, %r15
jne 0x2535c
movq %rsp, %rbx
movl $0x4, %edi
movq %rbx, %rsi
callq 0x1f530
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
imulq $0x3e8, %rsi, %rdi      # imm = 0x3E8
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
addq %rdi, %rdx
movq %rdx, 0x23316(%rip)     # 0x486e8
imulq $0xf4240, %rsi, %rsi    # imm = 0xF4240
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
addq %rsi, %rdx
movq %rdx, 0x232ef(%rip)     # 0x486f0
movl $0x2, 0x22369(%rip)     # 0x47774
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movzbl (%rdi), %edi
leaq 0x1(%r12), %rcx
movq 0x21a27(%rip), %rax     # 0x46f48
movzwl (%rax), %r8d
movl $0x2, %esi
movl $0x6, %edx
callq 0x1f630
movzwl 0x1(%r12), %eax
shrl $0x6, %eax
movw %ax, (%r15)
movzwl 0x3(%r12), %eax
shrl $0x6, %eax
movw %ax, (%r14)
movzwl 0x5(%r12), %eax
shrl $0x6, %eax
movw %ax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1(%rdi), %r14
movq 0x20ded(%rip), %r15     # 0x46f48
movzbl (%rbx), %edi
movzwl (%r15), %ecx
movl $0xf4, %esi
movq %r14, %rdx
callq 0x1f6d0
testb $0x20, 0x1(%rbx)
jne 0x2615b
movzbl (%rbx), %edi
movzwl (%r15), %r8d
movl $0xf6, %esi
movl $0x2, %edx
movq %r14, %rcx
callq 0x1f630
movzwl 0x1(%rbx), %eax
rolw $0x8, %ax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1(%rdi), %r14
movq 0x20d99(%rip), %r15     # 0x46f48
movzbl (%rbx), %edi
movzwl (%r15), %ecx
movl $0xf4, %esi
movq %r14, %rdx
callq 0x1f6d0
testb $0x20, 0x1(%rbx)
jne 0x261af
movzbl (%rbx), %edi
movzwl (%r15), %r8d
movl $0xf6, %esi
movl $0x3, %edx
movq %r14, %rcx
callq 0x1f630
movzbl 0x1(%rbx), %eax
shll $0x10, %eax
movzbl 0x2(%rbx), %ecx
shll $0x8, %ecx
orl %eax, %ecx
movzbl 0x3(%rbx), %eax
orl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movss 0xfd0b(%rip), %xmm0     # 0x35f94
cmpb $0x2e, 0x20(%rdi)
jne 0x262e4
movq %rdi, %rbx
callq 0x1f210
movss 0xfcf5(%rip), %xmm0     # 0x35f94
testw %ax, %ax
je 0x262e4
movzwl %ax, %eax
movzwl 0x1a(%rbx), %ecx
subl %ecx, %eax
movzwl 0x18(%rbx), %ecx
imull %eax, %ecx
sarl $0xf, %ecx
movswl 0x12(%rbx), %eax
shll $0xb, %eax
movswl 0x14(%rbx), %esi
addl %ecx, %esi
cltd
idivl %esi
leal (%rcx,%rax), %edx
addl $0x8, %edx
sarl $0x4, %edx
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
addl %ecx, %eax
movl %eax, 0x1c(%rbx)
divss 0xfcb4(%rip), %xmm0     # 0x35f98
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mrlordkaj[P]i2cdevlib-pi/BMP085/BMP085.cpp
// Function: BMP085::getPressure()
int32_t BMP085::getPressure() {
    /*
    Datasheet forumla
        UP = raw pressure
        B6 = B5 - 4000
        X1 = (B2 * (B6 * B6 / 2^12)) / 2^11
        X2 = AC2 * B6 / 2^11
        X3 = X1 + X2
        B3 = ((AC1 * 4 + X3) << oss + 2) / 4
        X1 = AC3 * B6 / 2^13
        X2 = (B1 * (B6 * B6 / 2^12)) / 2^16
        X3 = ((X1 + X2) + 2) / 2^2
        B4 = AC4 * (unsigned long)(X3 + 32768) / 2^15
        B7 = ((unsigned long)UP - B3) * (50000 >> oss)
        if (B7 < 0x80000000) { p = (B7 * 2) / B4 }
        else { p = (B7 / B4) * 2 }
        X1 = (p / 2^8) * (p / 2^8)
        X1 = (X1 * 3038) / 2^16
        X2 = (-7357 * p) / 2^16
        p = p + (X1 + X2 + 3791) / 2^4
    */
    uint32_t up = getRawPressure();
    if(up == 0) return 0;
    uint8_t oss = (measureMode & 0xC0) >> 6;
    int32_t p;
    int32_t b6 = b5 - 4000;
    int32_t x1 = ((int32_t)b2 * ((b6 * b6) >> 12)) >> 11;
    int32_t x2 = ((int32_t)ac2 * b6) >> 11;
    int32_t x3 = x1 + x2;
    int32_t b3 = ((((int32_t)ac1 * 4 + x3) << oss) + 2) >> 2;
    x1 = ((int32_t)ac3 * b6) >> 13;
    x2 = ((int32_t)b1 * ((b6 * b6) >> 12)) >> 16;
    x3 = ((x1 + x2) + 2) >> 2;
    uint32_t b4 = ((uint32_t)ac4 * (uint32_t)(x3 + 32768)) >> 15;
    uint32_t b7 = ((uint32_t)up - b3) * (uint32_t)(50000UL >> oss);
    if (b7 < 0x80000000) {
        p = (b7 << 1) / b4;
    } else {
        p = (b7 / b4) << 1;
    }
    x1 = (p >> 8) * (p >> 8);
    x1 = (x1 * 3038) >> 16;
    x2 = (-7357 * p) >> 16;
    return p + ((x1 + x2 + (int32_t)3791) >> 4);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testb $0x34, 0x20(%rdi)
je 0x2640b
movq %rdi, %rbx
callq 0x1f030
movzbl 0x20(%rbx), %edx
shrl $0x6, %edx
movb $0x8, %cl
subb %dl, %cl
shrl %cl, %eax
testl %eax, %eax
je 0x2640b
movl $0xfffff060, %esi       # imm = 0xFFFFF060
addl 0x1c(%rbx), %esi
movswl 0xe(%rbx), %ecx
movswl 0x8(%rbx), %edi
imull %esi, %edi
movswl 0xa(%rbx), %r9d
imull %esi, %r9d
imull %esi, %esi
shrl $0xc, %esi
imull %esi, %ecx
sarl $0xb, %ecx
sarl $0xb, %edi
addl %ecx, %edi
movswl 0x6(%rbx), %ecx
leal (%rdi,%rcx,4), %r8d
movl %edx, %ecx
shll %cl, %r8d
addl $0x2, %r8d
sarl $0x2, %r8d
sarl $0xd, %r9d
movswl 0xc(%rbx), %ecx
imull %esi, %ecx
sarl $0x10, %ecx
leal (%r9,%rcx), %edi
addl $0x2, %edi
sarl $0x2, %edi
movzwl 0x16(%rbx), %ecx
addl $0x8000, %edi           # imm = 0x8000
imull %ecx, %edi
movl $0xc350, %esi           # imm = 0xC350
movl %edx, %ecx
shrl %cl, %esi
shrl $0xf, %edi
subl %r8d, %eax
imull %eax, %esi
testl %esi, %esi
js 0x263db
addl %esi, %esi
movl %esi, %eax
xorl %edx, %edx
divl %edi
jmp 0x263e3
movl %esi, %eax
xorl %edx, %edx
divl %edi
addl %eax, %eax
movl %eax, %ecx
sarl $0x8, %ecx
imull %ecx, %ecx
imull $0xbde, %ecx, %ecx      # imm = 0xBDE
shrl $0x10, %ecx
imull $0xffffe343, %eax, %edx # imm = 0xFFFFE343
sarl $0x10, %edx
leal (%rdx,%rcx), %ebp
addl $0xecf, %ebp            # imm = 0xECF
sarl $0x4, %ebp
addl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq