LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mrlordkaj[P]i2cdevlib-pi/AK8963/AK8963.cpp
// Function: AK8963::setAdjustment(signed char, signed char, signed char)
void AK8963::setAdjustment(int8_t x, int8_t y, int8_t z) {
    buffer[0] = x;
    buffer[1] = y;
    buffer[2] = z;
    I2Cdev::writeBytes(devAddr, AK8963_RA_ASAX, 3, buffer);
}

// 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), %rcx
movb 0xf(%rsp), %al
movb %al, 0x1(%rcx)
movb 0xe(%rsp), %al
movb %al, 0x2(%rcx)
movb 0xd(%rsp), %al
movb %al, 0x3(%rcx)
movb (%rcx), %al
addq $0x1, %rcx
movl $0x10, %esi
movl $0x3, %edx
movzbl %al, %edi
callq 0x22290
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/AK8975/AK8975.cpp
// Function: AK8975::getHeading(short*, short*, short*)
void AK8975::getHeading(int16_t *x, int16_t *y, int16_t *z) {
    I2Cdev::writeByte(devAddr, AK8975_RA_CNTL, AK8975_MODE_SINGLE);
    delay(10);
    I2Cdev::readBytes(devAddr, AK8975_RA_HXL, 6, buffer);
    *x = (((int16_t)buffer[1]) << 8) | buffer[0];
    *y = (((int16_t)buffer[3]) << 8) | buffer[2];
    *z = (((int16_t)buffer[5]) << 8) | buffer[4];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0xa, %esi
movl $0x1, %edx
movzbl (%rax), %edi
callq 0x22ad0
movl $0xa, %edi
callq 0x228c0
movq (%rsp), %rcx
movb (%rcx), %dil
addq $0x1, %rcx
movl $0x3, %esi
movl $0x6, %edx
movq 0x340ff(%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
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
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
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/AK8975/AK8975.cpp
// Function: AK8975::getHeadingX()
int16_t AK8975::getHeadingX() {
    I2Cdev::writeByte(devAddr, AK8975_RA_CNTL, AK8975_MODE_SINGLE);
    delay(10);
    I2Cdev::readBytes(devAddr, AK8975_RA_HXL, 2, buffer);
    return (((int16_t)buffer[1]) << 8) | buffer[0];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xa, %esi
movl $0x1, %edx
movzbl (%rax), %edi
callq 0x22ad0
movl $0xa, %edi
callq 0x228c0
movq 0x8(%rsp), %rcx
movb (%rcx), %dil
addq $0x1, %rcx
movl $0x3, %esi
movl $0x2, %edx
movq 0x3404c(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq 0x8(%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/AK8975/AK8975.cpp
// Function: AK8975::getHeadingZ()
int16_t AK8975::getHeadingZ() {
    I2Cdev::writeByte(devAddr, AK8975_RA_CNTL, AK8975_MODE_SINGLE);
    delay(10);
    I2Cdev::readBytes(devAddr, AK8975_RA_HZL, 2, buffer);
    return (((int16_t)buffer[1]) << 8) | buffer[0];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xa, %esi
movl $0x1, %edx
movzbl (%rax), %edi
callq 0x22ad0
movl $0xa, %edi
callq 0x228c0
movq 0x8(%rsp), %rcx
movb (%rcx), %dil
addq $0x1, %rcx
movl $0x7, %esi
movl $0x2, %edx
movq 0x33f4c(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq 0x8(%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/AK8975/AK8975.cpp
// Function: AK8975::getAdjustment(signed char*, signed char*, signed char*)
void AK8975::getAdjustment(int8_t *x, int8_t *y, int8_t *z) {
    I2Cdev::writeByte(devAddr, AK8975_RA_CNTL, 0x0F); // Enter Fuse ROM access mode
    delay(10);
    I2Cdev::readBytes(devAddr, AK8975_RA_ASAX, 3, buffer);
    *x = buffer[0];
    *y = buffer[1];
    *z = buffer[2];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0xa, %esi
movl $0xf, %edx
movzbl (%rax), %edi
callq 0x22ad0
movl $0xa, %edi
callq 0x228c0
movq (%rsp), %rcx
movb (%rcx), %dil
addq $0x1, %rcx
movl $0x10, %esi
movl $0x3, %edx
movq 0x33cff(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rax
movb 0x1(%rax), %dl
movq 0x18(%rsp), %rcx
movb %dl, (%rcx)
movb 0x2(%rax), %dl
movq 0x10(%rsp), %rcx
movb %dl, (%rcx)
movb 0x3(%rax), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/AK8975/AK8975.cpp
// Function: AK8975::setAdjustment(signed char, signed char, signed char)
void AK8975::setAdjustment(int8_t x, int8_t y, int8_t z) {
    I2Cdev::writeByte(devAddr, AK8975_RA_CNTL, 0x0F); // Enter Fuse ROM access mode
    delay(10);
    buffer[0] = x;
    buffer[1] = y;
    buffer[2] = z;
    I2Cdev::writeBytes(devAddr, AK8975_RA_ASAX, 3, buffer);
}

// 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), %rax
movq %rax, (%rsp)
movl $0xa, %esi
movl $0xf, %edx
movzbl (%rax), %edi
callq 0x22ad0
movl $0xa, %edi
callq 0x228c0
movq (%rsp), %rcx
movb 0xf(%rsp), %al
movb %al, 0x1(%rcx)
movb 0xe(%rsp), %al
movb %al, 0x2(%rcx)
movb 0xd(%rsp), %al
movb %al, 0x3(%rcx)
movb (%rcx), %al
addq $0x1, %rcx
movl $0x10, %esi
movl $0x3, %edx
movzbl %al, %edi
callq 0x22290
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/AK8975/AK8975.cpp
// Function: AK8975::getAdjustmentX()
uint8_t AK8975::getAdjustmentX() {
    I2Cdev::writeByte(devAddr, AK8975_RA_CNTL, 0x0F); // Enter Fuse ROM access mode
    delay(10);
    I2Cdev::readByte(devAddr, AK8975_RA_ASAX, buffer);
    return buffer[0];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xa, %esi
movl $0xf, %edx
movzbl (%rax), %edi
callq 0x22ad0
movl $0xa, %edi
callq 0x228c0
movq 0x8(%rsp), %rdx
movb (%rdx), %cl
addq $0x1, %rdx
movl $0x10, %esi
movq 0x33c02(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22ce0
movq 0x8(%rsp), %rax
movb 0x1(%rax), %al
addq $0x18, %rsp
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/AK8975/AK8975.cpp
// Function: AK8975::getAdjustmentY()
uint8_t AK8975::getAdjustmentY() {
    I2Cdev::writeByte(devAddr, AK8975_RA_CNTL, 0x0F); // Enter Fuse ROM access mode
    delay(10);
    I2Cdev::readByte(devAddr, AK8975_RA_ASAY, buffer);
    return buffer[0];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xa, %esi
movl $0xf, %edx
movzbl (%rax), %edi
callq 0x22ad0
movl $0xa, %edi
callq 0x228c0
movq 0x8(%rsp), %rdx
movb (%rdx), %cl
addq $0x1, %rdx
movl $0x11, %esi
movq 0x33b42(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22ce0
movq 0x8(%rsp), %rax
movb 0x1(%rax), %al
addq $0x18, %rsp
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/Arduino.cpp
// Function: Serial::begin(int)
void _Serial::begin(int baudrate) {
    if (!inRunning) {
        inRunning = true;
        std::thread inThread(getLineFromCin, this);
        inThread.detach();
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, (%rax)
jne 0x28636
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
movq %rax, 0x28(%rsp)
leaq 0x60(%rip), %rsi        # 0x28650
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x28(%rsp), %rdx
callq 0x22820
movq 0x8(%rsp), %rdi
callq 0x23330
jmp 0x28610
leaq 0x30(%rsp), %rdi
callq 0x23120
jmp 0x28636
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x23120
jmp 0x2863b
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x23350
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/Arduino.cpp
// Function: getLineFromCin(_Serial*)
static void getLineFromCin(_Serial *serial) {
    std::string line;
    while (serial->inRunning) {
        std::getline(std::cin, line);
        serial->inChars.append(line);
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x22ef0
movq 0x30(%rsp), %rax
testb $0x1, (%rax)
je 0x286b1
movq 0x33954(%rip), %rdi     # 0x5bfc8
leaq 0x10(%rsp), %rsi
callq 0x220e0
jmp 0x28680
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
leaq 0x10(%rsp), %rsi
callq 0x23570
jmp 0x28695
jmp 0x28663
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x8(%rsp)
movl %eax, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x226d0
jmp 0x286c0
leaq 0x10(%rsp), %rdi
callq 0x226d0
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x23350
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/Arduino.cpp
// Function: Serial::read()
int _Serial::read() {
    if (inChars.length() > 0) {
        int d = inChars.at(0);
        inChars.erase(0);
        return d;
    }
    return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
callq 0x23070
cmpq $0x0, %rax
jbe 0x2875e
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x23520
movq 0x8(%rsp), %rdi
movsbl (%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
movq $-0x1, %rdx
callq 0x221a0
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x28766
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/Arduino.cpp
// Function: Serial::print(long, int)
void _Serial::print(long val, int format) {
    switch (format) {
        case HEX:
            std::cout << std::hex << std::uppercase << val;
            return;
        case DEC:
            std::cout << std::dec << val;
            return;
        case OCT:
            std::cout << std::oct << val;
            return;
        case BIN:
            std::cout << std::bitset<8>(val);
            return;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0xe, %eax
ja 0x28881
movq (%rsp), %rax
leaq 0x228ad(%rip), %rcx     # 0x4b090
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x33785(%rip), %rdi     # 0x5bf78
movq 0x337ee(%rip), %rsi     # 0x5bfe8
callq 0x22300
movq %rax, %rdi
movq 0x3378f(%rip), %rsi     # 0x5bf98
callq 0x22300
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x23410
jmp 0x28881
movq 0x33754(%rip), %rdi     # 0x5bf78
movq 0x3373d(%rip), %rsi     # 0x5bf68
callq 0x22300
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x23410
jmp 0x28881
movq 0x33732(%rip), %rdi     # 0x5bf78
movq 0x336eb(%rip), %rsi     # 0x5bf38
callq 0x22300
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x23410
jmp 0x28881
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x22540
movq 0x33701(%rip), %rdi     # 0x5bf78
leaq 0x8(%rsp), %rsi
callq 0x22dd0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/Wire.cpp
// Function: TwoWire::begin()
void TwoWire::begin() {
    if (fd < 0) {
        int rev = piGpioLayout();
        const char *device = (rev == 1) ? "/dev/i2c-0" : "/dev/i2c-1";
        if ((fd = open(device, O_RDWR)) < 0) {
            std::cerr << "Failed to open I2C port: " << strerror(errno) << "\r\n" << std::flush;
        }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x4(%rax)
jge 0x29702
callq 0x235b0
movl %eax, 0x2c(%rsp)
cmpl $0x1, 0x2c(%rsp)
jne 0x2967b
leaq 0x21b12(%rip), %rax     # 0x4b186
movq %rax, 0x10(%rsp)
jmp 0x29689
leaq 0x21b0f(%rip), %rax     # 0x4b191
movq %rax, 0x10(%rsp)
jmp 0x29689
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x227b0
movq 0x18(%rsp), %rcx
movl %eax, 0x4(%rcx)
cmpl $0x0, %eax
jge 0x29700
movq 0x32938(%rip), %rdi     # 0x5bff0
leaq 0x21add(%rip), %rsi     # 0x4b19c
callq 0x22aa0
movq %rax, 0x8(%rsp)
callq 0x22050
movl (%rax), %edi
callq 0x222f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x22aa0
movq %rax, %rdi
leaq 0x21b0f(%rip), %rsi     # 0x4b1fb
callq 0x22aa0
movq %rax, %rdi
movq 0x32885(%rip), %rsi     # 0x5bf80
callq 0x22b70
jmp 0x29702
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/Wire.cpp
// Function: TwoWire::begin(unsigned char)
void TwoWire::begin(uint8_t address) {
    begin();
    if (address != addr) {
        addr = address;
        if (fd < 0 || ioctl(fd, I2C_SLAVE, address) < 0) {
            std::cerr << "Failed to open I2C device: " << strerror(errno) << "\r\n" << std::flush;
            addr = 0;
        }
    }
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x22e50
movq 0x10(%rsp), %rcx
movzbl 0x1f(%rsp), %eax
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x297cc
movq 0x10(%rsp), %rax
movb 0x1f(%rsp), %cl
movb %cl, (%rax)
cmpl $0x0, 0x4(%rax)
jl 0x29773
movq 0x10(%rsp), %rax
movl 0x4(%rax), %edi
movzbl 0x1f(%rsp), %edx
movl $0x703, %esi            # imm = 0x703
movb $0x0, %al
callq 0x22f60
cmpl $0x0, %eax
jge 0x297ca
movq 0x32876(%rip), %rdi     # 0x5bff0
leaq 0x21a35(%rip), %rsi     # 0x4b1b6
callq 0x22aa0
movq %rax, 0x8(%rsp)
callq 0x22050
movl (%rax), %edi
callq 0x222f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x22aa0
movq %rax, %rdi
leaq 0x21a4d(%rip), %rsi     # 0x4b1fb
callq 0x22aa0
movq %rax, %rdi
movq 0x327c3(%rip), %rsi     # 0x5bf80
callq 0x22b70
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
jmp 0x297cc
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/Wire.cpp
// Function: TwoWire::end()
void TwoWire::end() {
    if (fd >= 0) {
        close(fd);
        fd = -1;
    }
    addr = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x4(%rax)
jl 0x29842
movq 0x8(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x23580
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
addq $0x18, %rsp
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/Wire.cpp
// Function: TwoWire::endTransmission(bool)
uint8_t TwoWire::endTransmission(bool sendStop) {
    // TODO: sendStop
    if (addr > 0 && fd >= 0) {
        if (writeOffset > 0) {
            int written = i2cWrite(fd, &writeBuffer, writeOffset);
            if (written < 0) {
                return 2; // address send, NACK received
            } else if (written < writeOffset) {
                return 3; // data send, NACK received
            }
        }
        return 0; // success
    }
    return 4; // other error
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl (%rax), %eax
cmpl $0x0, %eax
jle 0x29984
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x29984
movq 0x8(%rsp), %rax
cmpl $0x0, 0x50(%rax)
jle 0x2997d
movq 0x8(%rsp), %rax
movl 0x4(%rax), %edi
movq %rax, %rsi
addq $0x30, %rsi
movslq 0x50(%rax), %rdx
callq 0x299a0
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jge 0x29964
movb $0x2, 0x27(%rsp)
jmp 0x29989
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x29979
movb $0x3, 0x27(%rsp)
jmp 0x29989
jmp 0x2997b
jmp 0x2997d
movb $0x0, 0x27(%rsp)
jmp 0x29989
movb $0x4, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/Wire.cpp
// Function: TwoWire::write(unsigned char const*, unsigned long)
size_t TwoWire::write(const uint8_t *data, size_t quantity) {
    if (addr > 0) {
        quantity = min(BUFFER_LENGTH-writeOffset, quantity);
        if (quantity > 0) {
            memcpy(writeBuffer+writeOffset, data, quantity);
            writeOffset += quantity;
            return quantity;
        }
        return 0;
    }
    return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movzbl (%rax), %eax
cmpl $0x0, %eax
jle 0x29aae
movq 0x10(%rsp), %rcx
movl $0x20, %eax
subl 0x50(%rcx), %eax
cltq
cmpq 0x18(%rsp), %rax
jae 0x29a45
movq 0x10(%rsp), %rcx
movl $0x20, %eax
subl 0x50(%rcx), %eax
cltq
movq %rax, 0x8(%rsp)
jmp 0x29a4f
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jbe 0x29aa3
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movslq 0x50(%rax), %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x228f0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
movslq 0x50(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x50(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x29ab7
movq $0x0, 0x30(%rsp)
jmp 0x29ab7
movq $-0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/Wire.cpp
// Function: TwoWire::requestFrom(unsigned char, unsigned char, unsigned int, unsigned char, unsigned char)
uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint32_t iaddress, uint8_t isize, uint8_t sendStop) {
    // TODO: sendStop
    
    if (isize > 0) {
        // send internal address
        beginTransmission(address);
        // the maximum size of internal address is 3 bytes
        if (isize > 3){
            isize = 3;
        }
        // write internal register address - most significant byte first
        while (isize-- > 0)
            write((uint8_t)(iaddress >> (isize*8)));
        endTransmission(false);
    }
    
    // send data
    beginTransmission(address);
    if (addr > 0) {
        if (quantity > BUFFER_LENGTH) {
            // clamp to buffer length
            quantity = BUFFER_LENGTH;
        }
        readAvailable = i2cRead(fd, (uint8_t*)&readBuffer, quantity);
        return readAvailable;
    }
    return -1;
}

// Assembly:
subq $0x38, %rsp
movl %r8d, (%rsp)
movl %ecx, %eax
movl (%rsp), %ecx
movl %eax, 0x4(%rsp)
movl %edx, %eax
movl 0x4(%rsp), %edx
movl %eax, 0x8(%rsp)
movl %esi, %eax
movl 0x8(%rsp), %esi
movl %eax, 0xc(%rsp)
movq %rdi, %r8
movl 0xc(%rsp), %edi
movb %r9b, %al
movq %r8, 0x28(%rsp)
movb %dil, 0x27(%rsp)
movb %sil, 0x26(%rsp)
movl %edx, 0x20(%rsp)
movb %cl, 0x1f(%rsp)
movb %al, 0x1e(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movzbl 0x1f(%rsp), %eax
cmpl $0x0, %eax
jle 0x29bbc
movq 0x10(%rsp), %rdi
movzbl 0x27(%rsp), %esi
callq 0x228e0
movzbl 0x1f(%rsp), %eax
cmpl $0x3, %eax
jle 0x29b7c
movb $0x3, 0x1f(%rsp)
jmp 0x29b7e
movb 0x1f(%rsp), %al
movb %al, %cl
addb $-0x1, %cl
movb %cl, 0x1f(%rsp)
movzbl %al, %eax
cmpl $0x0, %eax
jle 0x29bb0
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %eax
movzbl 0x1f(%rsp), %ecx
shll $0x3, %ecx
shrl %cl, %eax
movzbl %al, %esi
callq 0x22810
jmp 0x29b7e
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x22bf0
movq 0x10(%rsp), %rdi
movzbl 0x27(%rsp), %esi
callq 0x228e0
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jle 0x29c13
movzbl 0x26(%rsp), %eax
cmpl $0x20, %eax
jle 0x29be7
movb $0x20, 0x26(%rsp)
movq 0x10(%rsp), %rsi
movl 0x4(%rsi), %edi
addq $0x8, %rsi
movzbl 0x26(%rsp), %eax
movl %eax, %edx
callq 0x29c30
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl %ecx, 0x28(%rax)
movl 0x28(%rax), %eax
movb %al, 0x37(%rsp)
jmp 0x29c18
movb $-0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/Wire.cpp
// Function: TwoWire::read()
int TwoWire::read() {
    if (readAvailable > 0) {
        uint8_t d = readBuffer[readOffset];
        readOffset++;
        readAvailable--;
        return d;
    }
    return -1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0x0, 0x28(%rax)
jle 0x29de3
movq -0x20(%rsp), %rax
movslq 0x2c(%rax), %rcx
movb 0x8(%rax,%rcx), %cl
movb %cl, -0x11(%rsp)
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movl 0x28(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x28(%rax)
movzbl -0x11(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x29deb
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/avr/dtostrf.c
// Function: dtostrf
char *dtostrf (double val, signed char width, unsigned char prec, char *sout) {
  char fmt[20];
  sprintf(fmt, "%%%d.%df", width, prec);
  sprintf(sout, fmt, val);
  return sout;
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movb %dil, %cl
movsd %xmm0, 0x30(%rsp)
movb %cl, 0x2f(%rsp)
movb %al, 0x2e(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsp, %rdi
movsbl 0x2f(%rsp), %edx
movzbl 0x2e(%rsp), %ecx
leaq 0x2135d(%rip), %rsi     # 0x4b1fe
movb $0x0, %al
callq 0x220d0
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
movsd 0x30(%rsp), %xmm0
movb $0x1, %al
callq 0x220d0
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/piHiPri.c
// Function: piHiPri
int piHiPri (const int pri)
{
  struct sched_param sched ;

  memset (&sched, 0, sizeof(sched)) ;

  if (pri > sched_get_priority_max (SCHED_RR))
    sched.sched_priority = sched_get_priority_max (SCHED_RR) ;
  else
    sched.sched_priority = pri ;

  return sched_setscheduler (0, SCHED_RR, &sched) ;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x22560
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl $0x2, %edi
callq 0x22a40
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jle 0x29f15
movl $0x2, %edi
callq 0x22a40
movl %eax, 0x10(%rsp)
jmp 0x29f1d
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
xorl %edi, %edi
movl $0x2, %esi
leaq 0x10(%rsp), %rdx
callq 0x231e0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/softPwm.c
// Function: softPwmWrite
void softPwmWrite (int pin, int value)
{
  if (pin < MAX_PINS)
  {
    /**/ if (value < 0)
      value = 0 ;
    else if (value > range [pin])
      value = range [pin] ;

    marks [pin] = value ;
  }
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
cmpl $0x40, -0x4(%rsp)
jge 0x29f9f
cmpl $0x0, -0x8(%rsp)
jge 0x29f60
movl $0x0, -0x8(%rsp)
jmp 0x29f8c
movl -0x8(%rsp), %eax
movslq -0x4(%rsp), %rdx
leaq 0x33610(%rip), %rcx     # 0x5d580
movl (%rcx,%rdx,4), %ecx
cmpl %ecx, %eax
jle 0x29f8a
movslq -0x4(%rsp), %rcx
leaq 0x335fd(%rip), %rax     # 0x5d580
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rsp)
jmp 0x29f8c
movl -0x8(%rsp), %edx
movslq -0x4(%rsp), %rcx
leaq 0x336e4(%rip), %rax     # 0x5d680
movl %edx, (%rax,%rcx,4)
retq
// File: 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:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
cmpl $0x40, 0x20(%rsp)
jl 0x29fc4
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2a0d2
movslq 0x20(%rsp), %rcx
leaq 0x335b0(%rip), %rax     # 0x5d580
movl (%rax,%rcx,4), %eax
cmpl $0x0, %eax
je 0x29fe5
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2a0d2
cmpl $0x0, 0x18(%rsp)
jg 0x29ff9
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2a0d2
movl $0x4, %edi
callq 0x22e40
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2a01b
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2a0d2
movl 0x20(%rsp), %edi
xorl %esi, %esi
callq 0x235e0
movl 0x20(%rsp), %edi
movl $0x1, %esi
callq 0x22680
movl 0x1c(%rsp), %edx
movslq 0x20(%rsp), %rcx
leaq 0x3363c(%rip), %rax     # 0x5d680
movl %edx, (%rax,%rcx,4)
movl 0x18(%rsp), %edx
movslq 0x20(%rsp), %rcx
leaq 0x33529(%rip), %rax     # 0x5d580
movl %edx, (%rax,%rcx,4)
movl 0x20(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movl 0x20(%rsp), %eax
movl %eax, 0x32aa2(%rip)     # 0x5cb10
movq (%rsp), %rcx
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x5e(%rip), %rdx        # 0x2a0e0
callq 0x233f0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x2a09c
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x2a0d2
jmp 0x2a09e
movl 0x32a6c(%rip), %eax     # 0x5cb10
cmpl $-0x1, %eax
je 0x2a0b5
movl $0x1, %edi
callq 0x228c0
jmp 0x2a09e
movq 0x8(%rsp), %rdx
movslq 0x20(%rsp), %rcx
leaq 0x336ba(%rip), %rax     # 0x5d780
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x2, %edi
callq 0x22a40
movl %eax, (%rsp)
callq 0x22980
movq %rax, %rdi
movl $0x2, %esi
movq %rsp, %rdx
callq 0x22740
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x22cf0
movl 0x329ea(%rip), %eax     # 0x5cb10
movl %eax, 0xc(%rsp)
movl $0xffffffff, 0x329dc(%rip) # imm = 0xFFFFFFFF
movl $0x5a, %edi
callq 0x22170
movslq 0xc(%rsp), %rcx
leaq 0x33536(%rip), %rax     # 0x5d680
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movslq 0xc(%rsp), %rcx
leaq 0x33423(%rip), %rax     # 0x5d580
movl (%rax,%rcx,4), %eax
subl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x2a17d
movl 0xc(%rsp), %edi
movl $0x1, %esi
callq 0x235e0
imull $0x64, 0x8(%rsp), %edi
callq 0x22650
cmpl $0x0, 0x4(%rsp)
je 0x2a199
movl 0xc(%rsp), %edi
xorl %esi, %esi
callq 0x235e0
imull $0x64, 0x4(%rsp), %edi
callq 0x22650
jmp 0x2a13e
nopw %cs:(%rax,%rax)
// File: 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 %rax
movl %edi, 0x4(%rsp)
cmpl $0x40, 0x4(%rsp)
jge 0x2a21e
movslq 0x4(%rsp), %rcx
leaq 0x333b8(%rip), %rax     # 0x5d580
movl (%rax,%rcx,4), %eax
cmpl $0x0, %eax
je 0x2a21c
movslq 0x4(%rsp), %rcx
leaq 0x335a4(%rip), %rax     # 0x5d780
movq (%rax,%rcx,8), %rdi
callq 0x22f30
movslq 0x4(%rsp), %rcx
leaq 0x3358f(%rip), %rax     # 0x5d780
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x229a0
movslq 0x4(%rsp), %rcx
leaq 0x33376(%rip), %rax     # 0x5d580
movl $0x0, (%rax,%rcx,4)
movl 0x4(%rsp), %edi
xorl %esi, %esi
callq 0x235e0
jmp 0x2a21e
popq %rax
retq
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/softTone.c
// Function: softToneWrite
void softToneWrite (int pin, int freq)
{
  pin &= 63 ;

  /**/ if (freq < 0)
    freq = 0 ;
  else if (freq > 5000)	// Max 5KHz
    freq = 5000 ;

  freqs [pin] = freq ;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl -0x4(%rsp), %eax
andl $0x3f, %eax
movl %eax, -0x4(%rsp)
cmpl $0x0, -0x8(%rsp)
jge 0x2a244
movl $0x0, -0x8(%rsp)
jmp 0x2a258
cmpl $0x1388, -0x8(%rsp)     # imm = 0x1388
jle 0x2a256
movl $0x1388, -0x8(%rsp)     # imm = 0x1388
jmp 0x2a258
movl -0x8(%rsp), %edx
movslq -0x4(%rsp), %rcx
leaq 0x33718(%rip), %rax     # 0x5d980
movl %edx, (%rax,%rcx,4)
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl 0x10(%rsp), %edi
movl $0x1, %esi
callq 0x22680
movl 0x10(%rsp), %edi
xorl %esi, %esi
callq 0x235e0
movslq 0x10(%rsp), %rcx
leaq 0x337e3(%rip), %rax     # 0x5da80
cmpq $0x0, (%rax,%rcx,8)
je 0x2a2ae
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x2a316
movslq 0x10(%rsp), %rcx
leaq 0x336c6(%rip), %rax     # 0x5d980
movl $0x0, (%rax,%rcx,4)
movl 0x10(%rsp), %eax
movl %eax, 0x32849(%rip)     # 0x5cb14
movq %rsp, %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x47(%rip), %rdx        # 0x2a320
movq %rcx, %rsi
callq 0x233f0
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0x32828(%rip)    # 0x5cb14
je 0x2a2fa
movl $0x1, %edi
callq 0x228c0
jmp 0x2a2e5
movq (%rsp), %rdx
movslq 0x10(%rsp), %rcx
leaq 0x33776(%rip), %rax     # 0x5da80
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x2, %edi
callq 0x22a40
movl %eax, (%rsp)
callq 0x22980
movq %rax, %rdi
movl $0x2, %esi
movq %rsp, %rdx
callq 0x22740
movl 0x327c3(%rip), %eax     # 0x5cb14
movl %eax, 0xc(%rsp)
movl $0xffffffff, 0x327b5(%rip) # imm = 0xFFFFFFFF
movl $0x32, %edi
callq 0x22170
movslq 0xc(%rsp), %rcx
leaq 0x3360b(%rip), %rax     # 0x5d980
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x2a38f
movl $0x1, %edi
callq 0x228c0
jmp 0x2a3c8
movl $0x7a120, %eax          # imm = 0x7A120
cltd
idivl 0x8(%rsp)
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %edi
movl $0x1, %esi
callq 0x235e0
movl 0x4(%rsp), %edi
callq 0x22650
movl 0xc(%rsp), %edi
xorl %esi, %esi
callq 0x235e0
movl 0x4(%rsp), %edi
callq 0x22650
jmp 0x2a369
nopw (%rax,%rax)
// File: 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 %rax
movl %edi, 0x4(%rsp)
movslq 0x4(%rsp), %rcx
leaq 0x3369f(%rip), %rax     # 0x5da80
cmpq $0x0, (%rax,%rcx,8)
je 0x2a435
movslq 0x4(%rsp), %rcx
leaq 0x3368c(%rip), %rax     # 0x5da80
movq (%rax,%rcx,8), %rdi
callq 0x22f30
movslq 0x4(%rsp), %rcx
leaq 0x33677(%rip), %rax     # 0x5da80
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x229a0
movslq 0x4(%rsp), %rcx
leaq 0x3365e(%rip), %rax     # 0x5da80
movq $0x0, (%rax,%rcx,8)
movl 0x4(%rsp), %edi
xorl %esi, %esi
callq 0x235e0
popq %rax
retq
nopw (%rax,%rax)
// File: 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:
subq $0x4d8, %rsp            # imm = 0x4D8
testb %al, %al
je 0x2a47c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %edi, 0x4d4(%rsp)
movq %rsi, 0x4c8(%rsp)
cmpl $0x0, 0x4d4(%rsp)
jne 0x2a4c2
movq 0x31af8(%rip), %rax     # 0x5bfa8
cmpl $0x0, (%rax)
je 0x2a4c2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x4d8, %rsp            # imm = 0x4D8
retq
leaq 0x4b0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x4e0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq 0xb0(%rsp), %rdi
movq 0x4c8(%rsp), %rdx
leaq 0x4b0(%rsp), %rcx
movl $0x3ff, %esi            # imm = 0x3FF
callq 0x22710
leaq 0x4b0(%rsp), %rax
movq 0x31a6d(%rip), %rax     # 0x5bf88
movq (%rax), %rdi
leaq 0xb0(%rsp), %rdx
leaq 0x20df1(%rip), %rsi     # 0x4b31e
movb $0x0, %al
callq 0x23000
movl $0x1, %edi
callq 0x22d20
nop
// File: 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 %rax
movq %rdi, (%rsp)
movq 0x316cc(%rip), %rax     # 0x5bf88
movq (%rax), %rdi
leaq 0x21233(%rip), %rsi     # 0x4baf9
movb $0x0, %al
callq 0x23000
movq 0x316b4(%rip), %rax     # 0x5bf88
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x21254(%rip), %rsi     # 0x4bb36
movb $0x0, %al
callq 0x23000
movq 0x31698(%rip), %rax     # 0x5bf88
movq (%rax), %rdi
leaq 0x21244(%rip), %rsi     # 0x4bb3e
movb $0x0, %al
callq 0x23000
movl $0x1, %edi
callq 0x22d20
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
cmpl $0x0, 0x31791(%rip)     # 0x5ccd4
je 0x2b557
cmpl $0x3, 0x31788(%rip)     # 0x5ccd4
je 0x2b557
cmpl $0x1, 0x3177f(%rip)     # 0x5ccd4
jne 0x2b5d1
cmpl $0x0, 0x14(%rsp)
jl 0x2b565
cmpl $0x2, 0x14(%rsp)
jle 0x2b567
jmp 0x2b5d1
movl 0x10(%rsp), %eax
andl $0x7, %eax
orl $0x5a000018, %eax       # imm = 0x5A000018
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edx
movq 0x32726(%rip), %rax     # 0x5dca8
movslq 0x14(%rsp), %rcx
movl %edx, 0x2c(%rax,%rcx,4)
movq 0x309ae(%rip), %rax     # 0x5bf40
cmpl $0x0, (%rax)
je 0x2b5cf
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
leaq 0x2005b(%rip), %rdi     # 0x4b605
movb $0x0, %al
callq 0x22060
movq 0x326f0(%rip), %rax     # 0x5dca8
movslq 0x14(%rsp), %rcx
movl 0x2c(%rax,%rcx,4), %esi
leaq 0x20067(%rip), %rdi     # 0x4b62f
movb $0x0, %al
callq 0x22060
jmp 0x2b5d1
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
andl $0x3f, %eax
movl %eax, -0x8(%rsp)
cmpl $0x0, 0x316de(%rip)     # 0x5ccd4
jne 0x2b60d
movq 0x32699(%rip), %rax     # 0x5dc98
movslq -0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rsp)
jmp 0x2b642
cmpl $0x3, 0x316c0(%rip)     # 0x5ccd4
jne 0x2b62b
movq 0x32683(%rip), %rax     # 0x5dca0
movslq -0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rsp)
jmp 0x2b640
cmpl $0x1, 0x316a2(%rip)     # 0x5ccd4
je 0x2b63e
movl $0x0, -0x4(%rsp)
jmp 0x2b68e
jmp 0x2b640
jmp 0x2b642
movslq -0x8(%rsp), %rcx
leaq 0x31692(%rip), %rax     # 0x5cce0
movzbl (%rax,%rcx), %eax
movl %eax, -0xc(%rsp)
movslq -0x8(%rsp), %rcx
leaq 0x316be(%rip), %rax     # 0x5cd20
movzbl (%rax,%rcx), %eax
movl %eax, -0x10(%rsp)
movq 0x3263f(%rip), %rax     # 0x5dcb0
movslq -0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x10(%rsp), %ecx
shrl %cl, %eax
andl $0x7, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: pwmSetMode
void pwmSetMode (int mode)
{
  if ((wiringPiMode == WPI_MODE_PINS) || (wiringPiMode == WPI_MODE_PHYS) || (wiringPiMode == WPI_MODE_GPIO))
  {
    if (mode == PWM_MODE_MS)
      *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
    else
      *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
  }
}

// Assembly:
movl %edi, -0x4(%rsp)
cmpl $0x0, 0x31629(%rip)     # 0x5ccd4
je 0x2b6bf
cmpl $0x3, 0x31620(%rip)     # 0x5ccd4
je 0x2b6bf
cmpl $0x1, 0x31617(%rip)     # 0x5ccd4
jne 0x2b6e4
cmpl $0x0, -0x4(%rsp)
jne 0x2b6d5
movq 0x325eb(%rip), %rax     # 0x5dcb8
movl $0x8181, (%rax)         # imm = 0x8181
jmp 0x2b6e2
movq 0x325dc(%rip), %rax     # 0x5dcb8
movl $0x101, (%rax)          # imm = 0x101
jmp 0x2b6e4
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divl %ecx
movl %edx, 0xc(%rsp)
movl 0x24(%rsp), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divl %ecx
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x2b783
jmp 0x2b7be
cmpl $0x64, 0x24(%rsp)
jae 0x2b795
movl 0x24(%rsp), %edi
callq 0x22520
jmp 0x2b7bc
movl 0x8(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x222b0
jmp 0x2b7be
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl -0x4(%rsp), %eax
andl $0x3f, %eax
movl %eax, -0x4(%rsp)
cmpl $0x0, 0x313aa(%rip)     # 0x5ccd4
jne 0x2b941
movq 0x32365(%rip), %rax     # 0x5dc98
movslq -0x4(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rsp)
jmp 0x2b971
cmpl $0x3, 0x3138c(%rip)     # 0x5ccd4
jne 0x2b95f
movq 0x3234f(%rip), %rax     # 0x5dca0
movslq -0x4(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rsp)
jmp 0x2b96f
cmpl $0x1, 0x3136e(%rip)     # 0x5ccd4
je 0x2b96d
jmp 0x2ba5e
jmp 0x2b96f
jmp 0x2b971
movl $0x124f800, %eax        # imm = 0x124F800
cltd
idivl -0x8(%rsp)
movl %eax, -0xc(%rsp)
movl $0x124f800, %eax        # imm = 0x124F800
cltd
idivl -0x8(%rsp)
movl %edx, -0x10(%rsp)
cvtsi2sdl -0x10(%rsp), %xmm0
movsd 0x1f875(%rip), %xmm1    # 0x4b210
mulsd %xmm1, %xmm0
movsd 0x1f861(%rip), %xmm1    # 0x4b208
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rsp)
cmpl $0xfff, -0xc(%rsp)      # imm = 0xFFF
jle 0x2b9c5
movl $0xfff, -0xc(%rsp)      # imm = 0xFFF
movq 0x322fc(%rip), %rax     # 0x5dcc8
movslq -0x4(%rsp), %rdx
leaq 0x31388(%rip), %rcx     # 0x5cd60
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movl $0x5a000001, (%rax,%rcx,4) # imm = 0x5A000001
movq 0x322db(%rip), %rax     # 0x5dcc8
movslq -0x4(%rsp), %rdx
leaq 0x31367(%rip), %rcx     # 0x5cd60
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x2ba0f
jmp 0x2b9e6
movl -0xc(%rsp), %edx
shll $0xc, %edx
orl $0x5a000000, %edx       # imm = 0x5A000000
orl -0x14(%rsp), %edx
movq 0x322a1(%rip), %rax     # 0x5dcc8
movslq -0x4(%rsp), %rsi
leaq 0x3136d(%rip), %rcx     # 0x5cda0
movzbl (%rcx,%rsi), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq 0x32284(%rip), %rax     # 0x5dcc8
movslq -0x4(%rsp), %rdx
leaq 0x31310(%rip), %rcx     # 0x5cd60
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movl $0x5a000011, (%rax,%rcx,4) # imm = 0x5A000011
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: wiringPiFindNode
struct wiringPiNodeStruct *wiringPiFindNode (int pin)
{
  struct wiringPiNodeStruct *node = wiringPiNodes ;

  while (node != NULL)
    if ((pin >= node->pinBase) && (pin <= node->pinMax))
      return node ;
    else
      node = node->next ;

  return NULL ;
}

// Assembly:
movl %edi, -0xc(%rsp)
movq 0x30545(%rip), %rax     # 0x5bfb0
movq (%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x2bab2
movl -0xc(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jl 0x2baa2
movl -0xc(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x2baa2
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x2babb
movq -0x18(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x2ba73
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
leaq 0x1fa4e(%rip), %rdi     # 0x4b711
callq 0x2bd90
movl 0x14(%rsp), %eax
andl $-0x40, %eax
cmpl $0x0, %eax
jne 0x2bd88
cmpl $0x0, 0x30ff5(%rip)     # 0x5ccd4
jne 0x2bcf6
movq 0x31fb0(%rip), %rax     # 0x5dc98
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
jmp 0x2bd23
cmpl $0x3, 0x30fd7(%rip)     # 0x5ccd4
jne 0x2bd14
movq 0x31f9a(%rip), %rax     # 0x5dca0
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
jmp 0x2bd21
cmpl $0x1, 0x30fb9(%rip)     # 0x5ccd4
je 0x2bd1f
jmp 0x2bd88
jmp 0x2bd21
jmp 0x2bd23
movslq 0x14(%rsp), %rcx
leaq 0x30fb1(%rip), %rax     # 0x5cce0
movzbl (%rax,%rcx), %eax
movl %eax, 0xc(%rsp)
movslq 0x14(%rsp), %rcx
leaq 0x30fdd(%rip), %rax     # 0x5cd20
movzbl (%rax,%rcx), %eax
movl %eax, 0x8(%rsp)
movq 0x31f5e(%rip), %rax     # 0x5dcb0
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movl 0x8(%rsp), %ecx
movl $0x7, %eax
shll %cl, %eax
xorl $-0x1, %eax
andl %eax, %edx
movl 0x10(%rsp), %eax
andl $0x7, %eax
movl 0x8(%rsp), %ecx
shll %cl, %eax
orl %eax, %edx
movq 0x31f30(%rip), %rax     # 0x5dcb0
movslq 0xc(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x18, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/Arduino/wiringPi/wiringPi.c
// Function: setupCheck
static void setupCheck (const char *fName)
{
  if (!wiringPiSetuped)
  {
    fprintf (stderr, "%s: You have not called one of the wiringPiSetup\n"
	"  functions, so I'm aborting your program before it crashes anyway.\n", fName) ;
    exit (EXIT_FAILURE) ;
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpl $0x0, 0x3217c(%rip)     # 0x5df18
jne 0x2bdc4
movq 0x301e3(%rip), %rax     # 0x5bf88
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x1fdbe(%rip), %rsi     # 0x4bb71
movb $0x0, %al
callq 0x23000
movl $0x1, %edi
callq 0x22d20
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq 0x2fc71(%rip), %rax     # 0x5bfb0
movq (%rax), %rax
movq %rax, (%rsp)
movl 0x10(%rsp), %eax
andl $-0x40, %eax
cmpl $0x0, %eax
jne 0x2c471
cmpl $0x2, 0x30977(%rip)     # 0x5ccd4
jne 0x2c3d1
movslq 0x10(%rsp), %rcx
leaq 0x30ab5(%rip), %rax     # 0x5ce20
cmpl $-0x1, (%rax,%rcx,4)
jne 0x2c37e
movl $0x0, 0x14(%rsp)
jmp 0x2c4a4
movslq 0x10(%rsp), %rcx
leaq 0x30a96(%rip), %rax     # 0x5ce20
movl (%rax,%rcx,4), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x234a0
movslq 0x10(%rsp), %rcx
leaq 0x30a7c(%rip), %rax     # 0x5ce20
movl (%rax,%rcx,4), %edi
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
callq 0x23030
movsbl 0xf(%rsp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x30, %edx
cmovel %ecx, %eax
movl %eax, 0x14(%rsp)
jmp 0x2c4a4
cmpl $0x0, 0x308fc(%rip)     # 0x5ccd4
jne 0x2c3ef
movq 0x318b7(%rip), %rax     # 0x5dc98
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
jmp 0x2c427
cmpl $0x3, 0x308de(%rip)     # 0x5ccd4
jne 0x2c40d
movq 0x318a1(%rip), %rax     # 0x5dca0
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
jmp 0x2c425
cmpl $0x1, 0x308c0(%rip)     # 0x5ccd4
je 0x2c423
movl $0x0, 0x14(%rsp)
jmp 0x2c4a4
jmp 0x2c425
jmp 0x2c427
jmp 0x2c429
movq 0x31880(%rip), %rax     # 0x5dcb0
movslq 0x10(%rsp), %rdx
leaq 0x30ae4(%rip), %rcx     # 0x5cf20
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl 0x10(%rsp), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2c467
movl $0x1, 0x14(%rsp)
jmp 0x2c4a4
movl $0x0, 0x14(%rsp)
jmp 0x2c4a4
movl 0x10(%rsp), %edi
callq 0x22cd0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x2c48e
movl $0x0, 0x14(%rsp)
jmp 0x2c4a4
movq (%rsp), %rax
movq 0x30(%rax), %rax
movq (%rsp), %rdi
movl 0x10(%rsp), %esi
callq *%rax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)