LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mrlordkaj[P]i2cdevlib-pi/MPU6050/MPU6050.cpp
// Function: MPU6050::readMemoryBlock(unsigned char*, unsigned short, unsigned char, unsigned char)
void MPU6050::readMemoryBlock(uint8_t *data, uint16_t dataSize, uint8_t bank, uint8_t address) {
    setMemoryBank(bank);
    setMemoryStartAddress(address);
    uint8_t chunkSize;
    for (uint16_t i = 0; i < dataSize;) {
        // determine correct chunk size according to bank position and data size
        chunkSize = MPU6050_DMP_MEMORY_CHUNK_SIZE;

        // make sure we don't go past the data size
        if (i + chunkSize > dataSize) chunkSize = dataSize - i;

        // make sure this chunk doesn't go past the bank boundary (256 bytes)
        if (chunkSize > 256 - address) chunkSize = 256 - address;

        // read the chunk of data as specified
        I2Cdev::readBytes(devAddr, MPU6050_RA_MEM_R_W, chunkSize, data + i);
        
        // increase byte index by [chunkSize]
        i += chunkSize;

        // uint8_t automatically wraps to 0 at 256
        address += chunkSize;

        // if we aren't done, update bank (if necessary) and address
        if (i < dataSize) {
            if (address == 0) bank++;
            setMemoryBank(bank);
            setMemoryStartAddress(address);
        }
    }
}

// Assembly:
subq $0x28, %rsp
movb %r8b, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movw %dx, 0x16(%rsp)
movb %cl, 0x15(%rsp)
movb %al, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %ecx, %ecx
movzbl 0x15(%rsp), %esi
movl %ecx, %edx
callq 0x22f00
movq 0x8(%rsp), %rdi
movzbl 0x14(%rsp), %esi
callq 0x23200
movw $0x0, 0x10(%rsp)
movzwl 0x10(%rsp), %eax
movzwl 0x16(%rsp), %ecx
cmpl %ecx, %eax
jge 0x4188e
movb $0x10, 0x13(%rsp)
movzwl 0x10(%rsp), %eax
movzbl 0x13(%rsp), %ecx
addl %ecx, %eax
movzwl 0x16(%rsp), %ecx
cmpl %ecx, %eax
jle 0x417c8
movzwl 0x16(%rsp), %eax
movzwl 0x10(%rsp), %ecx
subl %ecx, %eax
movb %al, 0x13(%rsp)
movzbl 0x13(%rsp), %eax
movzbl 0x14(%rsp), %edx
movl $0x100, %ecx            # imm = 0x100
subl %edx, %ecx
cmpl %ecx, %eax
jle 0x417ed
movzbl 0x14(%rsp), %ecx
movl $0x100, %eax            # imm = 0x100
subl %ecx, %eax
movb %al, 0x13(%rsp)
movq 0x8(%rsp), %rax
movb (%rax), %dil
movb 0x13(%rsp), %dl
movq 0x18(%rsp), %rcx
movzwl 0x10(%rsp), %eax
cltq
addq %rax, %rcx
movl $0x6f, %esi
movq 0x1a704(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzbl %dl, %edx
movzwl (%rax), %r8d
callq 0x22b50
movzbl 0x13(%rsp), %ecx
movzwl 0x10(%rsp), %eax
addl %ecx, %eax
movw %ax, 0x10(%rsp)
movzbl 0x13(%rsp), %ecx
movzbl 0x14(%rsp), %eax
addl %ecx, %eax
movb %al, 0x14(%rsp)
movzwl 0x10(%rsp), %eax
movzwl 0x16(%rsp), %ecx
cmpl %ecx, %eax
jge 0x41889
movzbl 0x14(%rsp), %eax
cmpl $0x0, %eax
jne 0x41867
movb 0x15(%rsp), %al
addb $0x1, %al
movb %al, 0x15(%rsp)
movq 0x8(%rsp), %rdi
xorl %ecx, %ecx
movzbl 0x15(%rsp), %esi
movl %ecx, %edx
callq 0x22f00
movq 0x8(%rsp), %rdi
movzbl 0x14(%rsp), %esi
callq 0x23200
jmp 0x4178c
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPU6050/MPU6050.cpp
// Function: MPU6050::CalibrateGyro(unsigned char)
void MPU6050::CalibrateGyro(uint8_t Loops ) {
  double kP = 0.3;
  double kI = 90;
  float x;
  x = (100 - map(Loops, 1, 5, 20, 0)) * .01;
  kP *= x;
  kI *= x;
  
  PID( 0x43,  kP, kI,  Loops);
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x9cde(%rip), %xmm0     # 0x4bd30
movsd %xmm0, 0x20(%rsp)
movsd 0x9cc8(%rip), %xmm0     # 0x4bd28
movsd %xmm0, 0x18(%rsp)
movzbl 0x2f(%rsp), %eax
movl %eax, %edi
movl $0x1, %esi
movl $0x5, %edx
movl $0x14, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x225f0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl $0x64, %eax
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd 0x9c7d(%rip), %xmm1     # 0x4bd20
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movsd 0x18(%rsp), %xmm1
cvtsd2ss %xmm1, %xmm1
movl $0x43, %esi
movzbl 0x2f(%rsp), %edx
callq 0x23190
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPU6050/MPU6050.cpp
// Function: MPU6050::CalibrateAccel(unsigned char)
void MPU6050::CalibrateAccel(uint8_t Loops ) {

	float kP = 0.3;
	float kI = 20;
	float x;
	x = (100 - map(Loops, 1, 5, 20, 0)) * .01;
	kP *= x;
	kI *= x;
	PID( 0x3B, kP, kI,  Loops);
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movss 0x941a(%rip), %xmm0     # 0x4bd6c
movss %xmm0, 0x18(%rsp)
movss 0x93b4(%rip), %xmm0     # 0x4bd14
movss %xmm0, 0x14(%rsp)
movzbl 0x1f(%rsp), %eax
movl %eax, %edi
movl $0x1, %esi
movl $0x5, %edx
movl $0x14, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x225f0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl $0x64, %eax
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd 0x937d(%rip), %xmm1     # 0x4bd20
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x10(%rsp), %xmm0
mulss 0x18(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movss 0x10(%rsp), %xmm0
mulss 0x14(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x18(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
movl $0x3b, %esi
movzbl 0x1f(%rsp), %edx
callq 0x23190
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPU9150/MPU9150.cpp
// Function: MPU9150::initialize()
void MPU9150::initialize() {
    setClockSource(MPU9150_CLOCK_PLL_XGYRO);
    setFullScaleGyroRange(MPU9150_GYRO_FS_250);
    setFullScaleAccelRange(MPU9150_ACCEL_FS_2);
    setSleepEnabled(false); // thanks to Jack Elston for pointing this one out!
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %esi
callq 0x23080
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x23220
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x229b0
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x229f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPU9150/MPU9150.cpp
// Function: MPU9150::getMotion9(short*, short*, short*, short*, short*, short*, short*, short*, short*)
void MPU9150::getMotion9(int16_t* ax, int16_t* ay, int16_t* az, int16_t* gx, int16_t* gy, int16_t* gz, int16_t* mx, int16_t* my, int16_t* mz) {

    //get accel and gyro
    getMotion6(ax, ay, az, gx, gy, gz);

    //read mag
    I2Cdev::writeByte(devAddr, MPU9150_RA_INT_PIN_CFG, 0x02); //set i2c bypass enable pin to true to access magnetometer
    delay(10);
    I2Cdev::writeByte(MPU9150_RA_MAG_ADDRESS, 0x0A, 0x01); //enable the magnetometer
    delay(10);
    I2Cdev::readBytes(MPU9150_RA_MAG_ADDRESS, MPU9150_RA_MAG_XOUT_L, 6, buffer);
    *mx = (((int16_t)buffer[0]) << 8) | buffer[1];
    *my = (((int16_t)buffer[2]) << 8) | buffer[3];
    *mz = (((int16_t)buffer[4]) << 8) | buffer[5];
}

// Assembly:
subq $0x48, %rsp
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
callq 0x22630
movq 0x10(%rsp), %rax
movl $0x37, %esi
movl $0x2, %edx
movzbl (%rax), %edi
callq 0x22ad0
movl $0xa, %edi
callq 0x228c0
movl $0xc, %edi
movl $0xa, %esi
movl $0x1, %edx
callq 0x22ad0
movl $0xa, %edi
callq 0x228c0
movq 0x10(%rsp), %rcx
addq $0x1, %rcx
movl $0xc, %edi
movl $0x3, %esi
movl $0x6, %edx
movq 0x16903(%rip), %rax     # 0x5bf18
movzwl (%rax), %r8d
callq 0x22b50
movq 0x10(%rsp), %rcx
movzbl 0x1(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x2(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x58(%rsp), %rax
movw %dx, (%rax)
movzbl 0x3(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x4(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x60(%rsp), %rax
movw %dx, (%rax)
movzbl 0x5(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x6(%rcx), %ecx
orl %ecx, %eax
movw %ax, %cx
movq 0x68(%rsp), %rax
movw %cx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPU9150/MPU9150.cpp
// Function: MPU9150::getSlaveDelayEnabled(unsigned char)
bool MPU9150::getSlaveDelayEnabled(uint8_t num) {
    // MPU9150_DELAYCTRL_I2C_SLV4_DLY_EN_BIT is 4, SLV3 is 3, etc.
    if (num > 4) return 0;
    I2Cdev::readBit(devAddr, MPU9150_RA_I2C_MST_DELAY_CTRL, num, buffer);
    return buffer[0];
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x4, %eax
jle 0x45f4b
movb $0x0, 0x27(%rsp)
jmp 0x45f89
movq 0x8(%rsp), %rcx
movb (%rcx), %dil
movb 0x17(%rsp), %dl
addq $0x1, %rcx
movl $0x67, %esi
movq 0x15fb1(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzbl %dl, %edx
movzwl (%rax), %r8d
callq 0x23320
movq 0x8(%rsp), %rax
cmpb $0x0, 0x1(%rax)
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPU9150/MPU9150.cpp
// Function: MPU9150::setMemoryBank(unsigned char, bool, bool)
void MPU9150::setMemoryBank(uint8_t bank, bool prefetchEnabled, bool userBank) {
    bank &= 0x1F;
    if (userBank) bank |= 0x20;
    if (prefetchEnabled) bank |= 0x40;
    I2Cdev::writeByte(devAddr, MPU9150_RA_BANK_SEL, bank);
}

// Assembly:
subq $0x18, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, 0x10(%rsp)
movb %dl, 0xf(%rsp)
andb $0x1, %cl
movb %cl, 0xe(%rsp)
andb $0x1, %al
movb %al, 0xd(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzbl 0xf(%rsp), %eax
andl $0x1f, %eax
movb %al, 0xf(%rsp)
testb $0x1, 0xd(%rsp)
je 0x47649
movzbl 0xf(%rsp), %eax
orl $0x20, %eax
movb %al, 0xf(%rsp)
testb $0x1, 0xe(%rsp)
je 0x4765c
movzbl 0xf(%rsp), %eax
orl $0x40, %eax
movb %al, 0xf(%rsp)
movq (%rsp), %rax
movb (%rax), %al
movl $0x6d, %esi
movzbl %al, %edi
movzbl 0xf(%rsp), %edx
callq 0x22ad0
addq $0x18, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPU9150/MPU9150.cpp
// Function: MPU9150::readMemoryBlock(unsigned char*, unsigned short, unsigned char, unsigned char)
void MPU9150::readMemoryBlock(uint8_t *data, uint16_t dataSize, uint8_t bank, uint8_t address) {
    setMemoryBank(bank);
    setMemoryStartAddress(address);
    uint8_t chunkSize;
    for (uint16_t i = 0; i < dataSize;) {
        // determine correct chunk size according to bank position and data size
        chunkSize = MPU9150_DMP_MEMORY_CHUNK_SIZE;

        // make sure we don't go past the data size
        if (i + chunkSize > dataSize) chunkSize = dataSize - i;

        // make sure this chunk doesn't go past the bank boundary (256 bytes)
        if (chunkSize > 256 - address) chunkSize = 256 - address;

        // read the chunk of data as specified
        I2Cdev::readBytes(devAddr, MPU9150_RA_MEM_R_W, chunkSize, data + i);
        
        // increase byte index by [chunkSize]
        i += chunkSize;

        // uint8_t automatically wraps to 0 at 256
        address += chunkSize;

        // if we aren't done, update bank (if necessary) and address
        if (i < dataSize) {
            if (address == 0) bank++;
            setMemoryBank(bank);
            setMemoryStartAddress(address);
        }
    }
}

// Assembly:
subq $0x28, %rsp
movb %r8b, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movw %dx, 0x16(%rsp)
movb %cl, 0x15(%rsp)
movb %al, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %ecx, %ecx
movzbl 0x15(%rsp), %esi
movl %ecx, %edx
callq 0x22b60
movq 0x8(%rsp), %rdi
movzbl 0x14(%rsp), %esi
callq 0x22fd0
movw $0x0, 0x10(%rsp)
movzwl 0x10(%rsp), %eax
movzwl 0x16(%rsp), %ecx
cmpl %ecx, %eax
jge 0x4786e
movb $0x10, 0x13(%rsp)
movzwl 0x10(%rsp), %eax
movzbl 0x13(%rsp), %ecx
addl %ecx, %eax
movzwl 0x16(%rsp), %ecx
cmpl %ecx, %eax
jle 0x477a8
movzwl 0x16(%rsp), %eax
movzwl 0x10(%rsp), %ecx
subl %ecx, %eax
movb %al, 0x13(%rsp)
movzbl 0x13(%rsp), %eax
movzbl 0x14(%rsp), %edx
movl $0x100, %ecx            # imm = 0x100
subl %edx, %ecx
cmpl %ecx, %eax
jle 0x477cd
movzbl 0x14(%rsp), %ecx
movl $0x100, %eax            # imm = 0x100
subl %ecx, %eax
movb %al, 0x13(%rsp)
movq 0x8(%rsp), %rax
movb (%rax), %dil
movb 0x13(%rsp), %dl
movq 0x18(%rsp), %rcx
movzwl 0x10(%rsp), %eax
cltq
addq %rax, %rcx
movl $0x6f, %esi
movq 0x14724(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzbl %dl, %edx
movzwl (%rax), %r8d
callq 0x22b50
movzbl 0x13(%rsp), %ecx
movzwl 0x10(%rsp), %eax
addl %ecx, %eax
movw %ax, 0x10(%rsp)
movzbl 0x13(%rsp), %ecx
movzbl 0x14(%rsp), %eax
addl %ecx, %eax
movb %al, 0x14(%rsp)
movzwl 0x10(%rsp), %eax
movzwl 0x16(%rsp), %ecx
cmpl %ecx, %eax
jge 0x47869
movzbl 0x14(%rsp), %eax
cmpl $0x0, %eax
jne 0x47847
movb 0x15(%rsp), %al
addb $0x1, %al
movb %al, 0x15(%rsp)
movq 0x8(%rsp), %rdi
xorl %ecx, %ecx
movzbl 0x15(%rsp), %esi
movl %ecx, %edx
callq 0x22b60
movq 0x8(%rsp), %rdi
movzbl 0x14(%rsp), %esi
callq 0x22fd0
jmp 0x4776c
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MS5803/MS5803.cpp
// Function: MS5803::MS5803(unsigned char)
MS5803::MS5803(uint8_t address) {
	setAddress(address);
	_initialized = false;
	_c1_SENSt1		= 0;
	_c2_OFFt1		= 0;
	_c3_TCS			= 0;
	_c4_TCO			= 0;
	_c5_Tref		= 0;
	_c6_TEMPSENS	= 0;
	_press_atm_mBar = (float)PRESS_ATM_MBAR_DEFAULT/1000.0; //default, can be changed with setAtmospheric() 
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movzbl 0xf(%rsp), %esi
callq 0x22400
movq (%rsp), %rax
movb $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x1c(%rax)
movl $0x0, 0x20(%rax)
movl $0x0, 0x24(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x2c(%rax)
movss 0x3d37(%rip), %xmm0     # 0x4bdc4
movss %xmm0, 0x54(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MS5803/MS5803.cpp
// Function: MS5803::_getCalConstants()
void MS5803::_getCalConstants(){
	/* Query and parse calibration constants */
	I2Cdev::readBytes(_dev_address,MS5803_PROM_C1,2,_buffer);
	_c1_SENSt1 =   (((uint16_t)_buffer[0] << 8) + _buffer[1]);
	I2Cdev::readBytes(_dev_address,MS5803_PROM_C2,2,_buffer);
	_c2_OFFt1 =    (((uint16_t)_buffer[0] << 8) + _buffer[1]);
	I2Cdev::readBytes(_dev_address,MS5803_PROM_C3,2,_buffer);
	_c3_TCS =      (((uint16_t)_buffer[0] << 8) + _buffer[1]);
	I2Cdev::readBytes(_dev_address,MS5803_PROM_C4,2,_buffer);
	_c4_TCO =      (((uint16_t)_buffer[0] << 8) + _buffer[1]);
	I2Cdev::readBytes(_dev_address,MS5803_PROM_C5,2,_buffer);
	_c5_Tref =     (((uint16_t)_buffer[0] << 8) + _buffer[1]);
	I2Cdev::readBytes(_dev_address,MS5803_PROM_C6,2,_buffer);
	_c6_TEMPSENS = (((uint16_t)_buffer[0] << 8) + _buffer[1]);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movb 0xe(%rcx), %dil
movl $0xa2, %esi
movl $0x2, %edx
movq 0x13ba0(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq 0x8(%rsp), %rcx
movzbl (%rcx), %eax
movzwl %ax, %eax
shll $0x8, %eax
movzbl 0x1(%rcx), %edx
addl %edx, %eax
movl %eax, 0x18(%rcx)
movb 0xe(%rcx), %dil
movl $0xa4, %esi
movl $0x2, %edx
movq 0x13b67(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq 0x8(%rsp), %rcx
movzbl (%rcx), %eax
movzwl %ax, %eax
shll $0x8, %eax
movzbl 0x1(%rcx), %edx
addl %edx, %eax
movl %eax, 0x1c(%rcx)
movb 0xe(%rcx), %dil
movl $0xa6, %esi
movl $0x2, %edx
movq 0x13b2e(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq 0x8(%rsp), %rcx
movzbl (%rcx), %eax
movzwl %ax, %eax
shll $0x8, %eax
movzbl 0x1(%rcx), %edx
addl %edx, %eax
movl %eax, 0x20(%rcx)
movb 0xe(%rcx), %dil
movl $0xa8, %esi
movl $0x2, %edx
movq 0x13af5(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq 0x8(%rsp), %rcx
movzbl (%rcx), %eax
movzwl %ax, %eax
shll $0x8, %eax
movzbl 0x1(%rcx), %edx
addl %edx, %eax
movl %eax, 0x24(%rcx)
movb 0xe(%rcx), %dil
movl $0xaa, %esi
movl $0x2, %edx
movq 0x13abc(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq 0x8(%rsp), %rcx
movzbl (%rcx), %eax
movzwl %ax, %eax
shll $0x8, %eax
movzbl 0x1(%rcx), %edx
addl %edx, %eax
movl %eax, 0x28(%rcx)
movb 0xe(%rcx), %dil
movl $0xac, %esi
movl $0x2, %edx
movq 0x13a83(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq 0x8(%rsp), %rax
movzbl (%rax), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
movzbl 0x1(%rax), %edx
addl %edx, %ecx
movl %ecx, 0x2c(%rax)
addq $0x18, %rsp
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/MS5803/MS5803.cpp
// Function: MS5803::_getCalConstant(unsigned char)
int32_t MS5803::_getCalConstant(uint8_t constant_no){
	switch ( constant_no ) {
		case 1: return _c1_SENSt1;
		case 2: return _c2_OFFt1;
		case 3: return _c3_TCS;
		case 4: return _c4_TCO;
		case 5: return _c5_Tref;
		case 6: return _c6_TEMPSENS;
		default: return 0;
	}
}

// Assembly:
movb %sil, %al
movq %rdi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movzbl -0x11(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rsp)
subl $0x5, %eax
ja 0x48552
movq -0x20(%rsp), %rax
leaq 0x394b(%rip), %rcx      # 0x4be40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x4855a
movq -0x28(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x4855a
movq -0x28(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x4855a
movq -0x28(%rsp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x4855a
movq -0x28(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x4855a
movq -0x28(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x4855a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/MS5803/MS5803.cpp
// Function: serialPrint64(long)
void serialPrint64(int64_t val64){
	int32_t result_high = val64 / 10000000L;
	int32_t result_low = val64 - (10000000LL * result_high);
	Serial.print(result_high);
	Serial.print(result_low);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x989680, %ecx         # imm = 0x989680
cqto
idivq %rcx
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
imulq $0x989680, %rcx, %rcx   # imm = 0x989680
subq %rcx, %rax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %esi
movq 0x12b21(%rip), %rdi     # 0x5bf60
callq 0x22ff0
movl 0x8(%rsp), %esi
movq 0x12b11(%rip), %rdi     # 0x5bf60
callq 0x22ff0
addq $0x18, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/SSD1308/SSD1308.cpp
// Function: SSD1308::clearDisplay()
void SSD1308::clearDisplay()
{
  setDisplayOff();
  setPageAddress(0, 7);     // all pages
  setColumnAddress(0, 127); // all columns
  for (uint8_t page = 0; page < 8; page++)
  {
    for (uint8_t col = 0; col < 128; col++)
    {
      sendData(0x0);
    }
  }
  setDisplayOn();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x22f20
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x23240
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x7f, %edx
callq 0x23530
movb $0x0, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x8, %eax
jge 0x496dc
movb $0x0, 0xe(%rsp)
movzbl 0xe(%rsp), %eax
cmpl $0x80, %eax
jge 0x496ce
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x22ec0
movb 0xe(%rsp), %al
addb $0x1, %al
movb %al, 0xe(%rsp)
jmp 0x496ab
jmp 0x496d0
movb 0xf(%rsp), %al
addb $0x1, %al
movb %al, 0xf(%rsp)
jmp 0x4969c
movq (%rsp), %rdi
callq 0x22240
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/SSD1308/SSD1308.cpp
// Function: SSD1308::fillDisplay()
void SSD1308::fillDisplay()
{
  setPageAddress(0, MAX_PAGE);      // all pages
  setColumnAddress(0, MAX_COL); // all columns

  uint8_t b = 0;
  for (uint8_t page = 0; page < PAGES; page++)
  {
    for (uint8_t col = 0; col < COLUMNS; col++)
    {
      sendData(b++);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x7, %edx
callq 0x23240
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x7f, %edx
callq 0x23530
movb $0x0, 0xf(%rsp)
movb $0x0, 0xe(%rsp)
movzbl 0xe(%rsp), %eax
cmpl $0x8, %eax
jge 0x49886
movb $0x0, 0xd(%rsp)
movzbl 0xd(%rsp), %eax
cmpl $0x80, %eax
jge 0x49878
movq (%rsp), %rdi
movb 0xf(%rsp), %al
movb %al, %cl
addb $0x1, %cl
movb %cl, 0xf(%rsp)
movzbl %al, %esi
callq 0x22ec0
movb 0xd(%rsp), %al
addb $0x1, %al
movb %al, 0xd(%rsp)
jmp 0x49847
jmp 0x4987a
movb 0xe(%rsp), %al
addb $0x1, %al
movb %al, 0xe(%rsp)
jmp 0x49838
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/SSD1308/SSD1308.cpp
// Function: SSD1308::writeChar(char)
void SSD1308::writeChar(char chr)
{
//#ifdef SSD1308_USE_FONT
  const uint8_t char_index = chr - 0x20;
  for (uint8_t i = 0; i < 8; i++) {
     const uint8_t b = pgm_read_byte( &fontData[char_index][i] );
     sendData( b ); 
  }
//#endif
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movsbl 0xf(%rsp), %eax
subl $0x20, %eax
movb %al, 0xe(%rsp)
movb $0x0, 0xd(%rsp)
movzbl 0xd(%rsp), %eax
cmpl $0x8, %eax
jge 0x498ff
movq (%rsp), %rdi
movzbl 0xe(%rsp), %eax
movl %eax, %ecx
leaq 0x28ba(%rip), %rax      # 0x4c190
shlq $0x3, %rcx
addq %rcx, %rax
movzbl 0xd(%rsp), %ecx
movb (%rax,%rcx), %al
movb %al, 0xc(%rsp)
movzbl 0xc(%rsp), %esi
callq 0x22ec0
movb 0xd(%rsp), %al
addb $0x1, %al
movb %al, 0xd(%rsp)
jmp 0x498ba
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/SSD1308/SSD1308.cpp
// Function: SSD1308::writeString(unsigned char, unsigned char, unsigned short, char const*)
void SSD1308::writeString(uint8_t row, uint8_t col, uint16_t len, const char * text)
{
  uint16_t index = 0;
  setPageAddress(row, MAX_PAGE);
  const uint8_t col_addr = FONT_WIDTH*col;
  setColumnAddress(col_addr, MAX_COL);

  while ((col+index) < CHARS && (index < len)) {
     // write first line, starting at given position
     writeChar(text[index++]);
  }

  // write remaining lines
  // write until the end of memory
  // then wrap around again from the top.
  if (index + 1 < len) {
    setPageAddress(row + 1, MAX_PAGE);
    setColumnAddress(0, MAX_COL);
    bool wrapEntireScreen = false;
    while (index + 1 < len) {
       writeChar(text[index++]);
       // if we've written the last character space on the screen, 
       // reset the page and column address so that it wraps around from the top again
       if (!wrapEntireScreen && (row*CHARS + col + index) > 127) {
         setPageAddress(0, MAX_PAGE);
         setColumnAddress(0, MAX_COL);
         wrapEntireScreen = true;
       }
    }
  }
}

// Assembly:
subq $0x38, %rsp
movw %cx, %ax
movb %dl, %cl
movb %sil, %dl
movq %rdi, 0x30(%rsp)
movb %dl, 0x2f(%rsp)
movb %cl, 0x2e(%rsp)
movw %ax, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movw $0x0, 0x1e(%rsp)
movl $0x7, %edx
movzbl 0x2f(%rsp), %esi
callq 0x23240
movq 0x10(%rsp), %rdi
movzbl 0x2e(%rsp), %eax
shll $0x3, %eax
movb %al, 0x1d(%rsp)
movl $0x7f, %edx
movzbl 0x1d(%rsp), %esi
callq 0x23530
movzbl 0x2e(%rsp), %ecx
movzwl 0x1e(%rsp), %eax
addl %eax, %ecx
xorl %eax, %eax
cmpl $0x10, %ecx
movb %al, 0xf(%rsp)
jge 0x4999d
movzwl 0x1e(%rsp), %eax
movzwl 0x2c(%rsp), %ecx
cmpl %ecx, %eax
setl %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x499a7
jmp 0x499d0
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movw 0x1e(%rsp), %cx
movw %cx, %dx
addw $0x1, %dx
movw %dx, 0x1e(%rsp)
movzwl %cx, %ecx
movsbl (%rax,%rcx), %esi
callq 0x22270
jmp 0x49973
movzwl 0x1e(%rsp), %eax
addl $0x1, %eax
movzwl 0x2c(%rsp), %ecx
cmpl %ecx, %eax
jge 0x49a9d
movq 0x10(%rsp), %rdi
movzbl 0x2f(%rsp), %eax
addl $0x1, %eax
movl $0x7, %edx
movzbl %al, %esi
callq 0x23240
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x7f, %edx
callq 0x23530
movb $0x0, 0x1c(%rsp)
movzwl 0x1e(%rsp), %eax
addl $0x1, %eax
movzwl 0x2c(%rsp), %ecx
cmpl %ecx, %eax
jge 0x49a9b
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movw 0x1e(%rsp), %cx
movw %cx, %dx
addw $0x1, %dx
movw %dx, 0x1e(%rsp)
movzwl %cx, %ecx
movsbl (%rax,%rcx), %esi
callq 0x22270
testb $0x1, 0x1c(%rsp)
jne 0x49a96
movzbl 0x2f(%rsp), %eax
shll $0x4, %eax
movzbl 0x2e(%rsp), %ecx
addl %ecx, %eax
movzwl 0x1e(%rsp), %ecx
addl %ecx, %eax
cmpl $0x7f, %eax
jle 0x49a96
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x23240
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x7f, %edx
callq 0x23530
movb $0x1, 0x1c(%rsp)
jmp 0x49a15
jmp 0x49a9d
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/SSD1308/SSD1308.cpp
// Function: SSD1308::setDisplayPower(bool)
void SSD1308::setDisplayPower(bool on)
{
  if (on) {
    setDisplayOn();
  } else {
    setDisplayOff();
  }
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0xf(%rsp)
je 0x49c0d
movq (%rsp), %rdi
callq 0x22240
jmp 0x49c16
movq (%rsp), %rdi
callq 0x22f20
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/TCA6424A/TCA6424A.cpp
// Function: TCA6424A::readAll(unsigned char*, unsigned char*, unsigned char*)
void TCA6424A::readAll(uint8_t *bank0, uint8_t *bank1, uint8_t *bank2) {
    I2Cdev::readBytes(devAddr, TCA6424A_RA_INPUT0, 3, buffer);
    *bank0 = buffer[0];
    *bank1 = buffer[1];
    *bank2 = 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), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
xorl %esi, %esi
movl $0x3, %edx
movq 0x12142(%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
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/TCA6424A/TCA6424A.cpp
// Function: TCA6424A::getAllOutputLevel(unsigned char*, unsigned char*, unsigned char*)
void TCA6424A::getAllOutputLevel(uint8_t *bank0, uint8_t *bank1, uint8_t *bank2) {
    I2Cdev::readBytes(devAddr, TCA6424A_RA_OUTPUT0, 3, buffer);
    *bank0 = buffer[0];
    *bank1 = buffer[1];
    *bank2 = 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), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
movl $0x4, %esi
movl $0x3, %edx
movq 0x11fcf(%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/TCA6424A/TCA6424A.cpp
// Function: TCA6424A::getAllPolarity(unsigned char*, unsigned char*, unsigned char*)
void TCA6424A::getAllPolarity(uint8_t *bank0, uint8_t *bank1, uint8_t *bank2) {
    I2Cdev::readBytes(devAddr, TCA6424A_RA_POLARITY0, 3, buffer);
    *bank0 = buffer[0];
    *bank1 = buffer[1];
    *bank2 = 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), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
movl $0x8, %esi
movl $0x3, %edx
movq 0x11d0f(%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/TCA6424A/TCA6424A.cpp
// Function: TCA6424A::setAllDirection(unsigned char, unsigned char, unsigned char)
void TCA6424A::setAllDirection(uint8_t bank0, uint8_t bank1, uint8_t bank2) {
    buffer[0] = bank0;
    buffer[1] = bank1;
    buffer[2] = bank2;
    I2Cdev::writeBytes(devAddr, TCA6424A_RA_CONFIG0 | TCA6424A_AUTO_INCREMENT, 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 $0x8c, %esi
movl $0x3, %edx
movzbl %al, %edi
callq 0x22290
addq $0x18, %rsp
retq
// File: yasz24[P]eau2/src/network/./network_ip.h
// Function: NetworkIP::send_msg(Message*)
void send_msg(Message* msg) {
        size_t target_node = msg->target();
        //std::cout << "send msg target: " << target_node << "\n";
        NodeInfo &target = nodes_[target_node];
        int server_port = ntohs(target.address.sin_port);
        char server_ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &target.address.sin_addr, server_ip, INET_ADDRSTRLEN);
        //std::cout << "attempting to send msg to: " << server_ip << ":" << server_port << "\n";
        int connection = socket(AF_INET, SOCK_STREAM, 0);
        assert(connection >= 0);
        if (connect(connection, (sockaddr*)&target.address, sizeof(target.address)) < 0) {
            perror("connection failed. Error");
            return;
        }
        msg->id_ = msg_id;
        msg_id++;
        //assert(connect(connection, (sockaddr*)&target.address, sizeof(target.address)) >= 0);
        char* serialized = msg->serialize();
        //std::cout << "sending msg: " << serialized << "\n";
        size_t length = strlen(serialized);
        send(connection, &length, sizeof(size_t), 0);
        send(connection, serialized, length, 0);
        close(connection);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9880
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rax
imulq $0x28, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x1a(%rax), %edi
callq 0x8440
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
addq $0x4, %rsi
leaq -0x40(%rbp), %rdx
movl $0x2, %edi
movl $0x10, %ecx
callq 0x82c0
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x80b0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jl 0x95da
jmp 0x95f9
leaq 0x22ba0(%rip), %rdi     # 0x2c181
leaq 0x22ba9(%rip), %rsi     # 0x2c191
movl $0x89, %edx
leaq 0x22bac(%rip), %rcx     # 0x2c1a0
callq 0x81a0
movl -0x44(%rbp), %edi
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
movl $0x10, %edx
callq 0x8210
cmpl $0x0, %eax
jge 0x9621
leaq 0x22bb2(%rip), %rdi     # 0x2c1cc
callq 0x8220
jmp 0x9685
movq -0x60(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x28(%rcx)
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x8130
movq %rax, -0x58(%rbp)
movl -0x44(%rbp), %edi
leaq -0x58(%rbp), %rsi
movl $0x8, %edx
xorl %ecx, %ecx
callq 0x8160
movl -0x44(%rbp), %edi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
xorl %ecx, %ecx
callq 0x8160
movl -0x44(%rbp), %edi
callq 0x8460
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./network_ip.h
// Function: NetworkIP::recv_msg()
Message* recv_msg() {
        sockaddr_in sender;
        socklen_t addrlen = sizeof(sender);
        int req = accept(sock_, (sockaddr*)&sender, &addrlen);
        size_t size = 0;
        read(req, &size, sizeof(size_t));
        char* buf = new char[size];
        int rd = 0;
        while (rd != size) {
            rd+= read(req, buf + rd, size - rd);
        }
        //std::cout << "received msg: " << buf << "\n";
        Deserializable ds;
        Message* msg = dynamic_cast<Message*>(ds.deserialize(buf));
        close(req);
        return msg;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10, -0x1c(%rbp)
movl 0x28(%rax), %edi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x80f0
movl %eax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x20(%rbp), %edi
leaq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0x8350
movq -0x28(%rbp), %rdi
callq 0x8030
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x971e
movl -0x20(%rbp), %edi
movq -0x30(%rbp), %rsi
movslq -0x34(%rbp), %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
movslq -0x34(%rbp), %rax
subq %rax, %rdx
callq 0x8350
movq %rax, %rcx
movslq -0x34(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x34(%rbp)
jmp 0x96e7
movq -0x30(%rbp), %rsi
leaq -0x35(%rbp), %rdi
callq 0x20680
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x9756
movq -0x48(%rbp), %rdi
leaq 0x30980(%rip), %rsi     # 0x3a0c0
leaq 0x30a81(%rip), %rdx     # 0x3a1c8
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x50(%rbp)
jmp 0x975e
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x975e
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x20(%rbp), %edi
callq 0x8460
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./network_ip.h
// Function: NetworkIP::init_sock_(char*, unsigned long)
void init_sock_(char* ip, size_t port) {
        assert((sock_ = socket(AF_INET, SOCK_STREAM, 0)) >= 0);
        int opt =1;
        assert(setsockopt(sock_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt) == 0));
        ip_.sin_family = AF_INET;
        //ip_.sin_addr.s_addr = inet_addr(ip);
        inet_pton(AF_INET, ip, &ip_.sin_addr);
        ip_.sin_port = htons(port);
        //int res = bind(sock_, (sockaddr*) &ip_, sizeof(ip_));
        if( bind(sock_, (sockaddr*) &ip_, sizeof(ip_)) < 0){
            perror("bind failed. Error");
            return;
        }
        if( (listen(sock_, 100)) < 0){
            perror("listen failed. Error");
            return;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x80b0
movq -0x28(%rbp), %rcx
movl %eax, 0x28(%rcx)
cmpl $0x0, %eax
jl 0x98db
jmp 0x98fa
leaq 0x2294b(%rip), %rdi     # 0x2c22d
leaq 0x228a8(%rip), %rsi     # 0x2c191
movl $0x6e, %edx
leaq 0x22967(%rip), %rcx     # 0x2c25c
callq 0x81a0
movq -0x28(%rbp), %rax
movl $0x1, -0x1c(%rbp)
movl 0x28(%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x1c(%rbp), %rcx
xorl %r8d, %r8d
callq 0x8420
cmpl $0x0, %eax
je 0x9925
jmp 0x9944
leaq 0x2295b(%rip), %rdi     # 0x2c287
leaq 0x2285e(%rip), %rsi     # 0x2c191
movl $0x70, %edx
leaq 0x2291d(%rip), %rcx     # 0x2c25c
callq 0x81a0
movq -0x28(%rbp), %rdx
movw $0x2, 0x2c(%rdx)
movq -0x10(%rbp), %rsi
addq $0x2c, %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0x8450
movq -0x18(%rbp), %rax
movzwl %ax, %edi
callq 0x8060
movq -0x28(%rbp), %rsi
movw %ax, 0x2e(%rsi)
movl 0x28(%rsi), %edi
addq $0x2c, %rsi
movl $0x10, %edx
callq 0x8070
cmpl $0x0, %eax
jge 0x999c
leaq 0x22936(%rip), %rdi     # 0x2c2cb
callq 0x8220
jmp 0x99be
movq -0x28(%rbp), %rax
movl 0x28(%rax), %edi
movl $0x64, %esi
callq 0x82e0
cmpl $0x0, %eax
jge 0x99be
leaq 0x22925(%rip), %rdi     # 0x2c2de
callq 0x8220
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./network.h
// Function: Register::Register(unsigned long, unsigned long, unsigned long, char*, unsigned long)
Register(size_t sender, size_t target, size_t id, char* addr, size_t port) {
        //std::cout << "registration constructor, port: " << port <<"\n";
        kind_ = (enum MsgKind)8;
        sender_ = sender;
        target_ = target; //assuming node 0 is server
        id_ = id; // no indexing right now.
        client = addr;
        port_ = port;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x9b00
movq -0x38(%rbp), %rax
leaq 0x307f8(%rip), %rcx     # 0x3a260
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x8, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x38(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./network.h
// Function: Register::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Register");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        sb->write("port", port_);
        sb->write("client", client);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0x9b9f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2280e(%rip), %rsi     # 0x2c3c0
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %edx
leaq 0x22732(%rip), %rsi     # 0x2c2fb
callq 0x9ed0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x22720(%rip), %rsi     # 0x2c301
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x22710(%rip), %rsi     # 0x2c309
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rdx
leaq 0x22a3b(%rip), %rsi     # 0x2c64c
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x38(%rax), %rdx
leaq 0x227a0(%rip), %rsi     # 0x2c3c9
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x30(%rax), %rdx
leaq 0x2278d(%rip), %rsi     # 0x2c3ce
callq 0xa6f0
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x9c7c
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./network.h
// Function: Message::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Message");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0x9d2f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x225b1(%rip), %rsi     # 0x2c2f3
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %edx
leaq 0x225a2(%rip), %rsi     # 0x2c2fb
callq 0x9ed0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x22590(%rip), %rsi     # 0x2c301
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x22580(%rip), %rsi     # 0x2c309
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rdx
leaq 0x228ab(%rip), %rsi     # 0x2c64c
callq 0x9f30
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x9ddc
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../utils/string.h
// Function: StrBuff::c(char const*)
StrBuff& c(const char* str) {
        size_t step = strlen(str);
        grow_by_(step);
        memcpy(val_+size_, str, step);
        size_ += step;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8130
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0xa160
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
addq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8200
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../utils/string.h
// Function: StrBuff::grow_by_(unsigned long)
void grow_by_(size_t step) {
        if (step + size_ < capacity_) return;
        capacity_ *= 2;
        if (step + size_ >= capacity_) capacity_ += step;        
        char* oldV = val_;
        val_ = new char[capacity_];
        memcpy(val_, oldV, size_);
        delete[] oldV;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq 0x20(%rcx), %rax
cmpq 0x18(%rcx), %rax
jae 0xa188
jmp 0xa1fd
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rax
shlq %rax
movq %rax, 0x18(%rcx)
movq -0x10(%rbp), %rax
addq 0x20(%rcx), %rax
cmpq 0x18(%rcx), %rax
jb 0xa1b5
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rdi
callq 0x8030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq 0x20(%rax), %rdx
callq 0x8200
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xa1fd
movq -0x28(%rbp), %rdi
callq 0x8300
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../utils/string.h
// Function: StrBuff::get()
String* get() {
        assert(val_ != nullptr); // can be called only once
        grow_by_(1);     // ensure space for terminator
        val_[size_] = '\0'; // terminate
        String *res = new String(true, val_, size_);
        val_ = new char[capacity_ = 10]; // val_ was consumed above
        size_ = 0;
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xa22d
jmp 0xa24c
leaq 0x2210b(%rip), %rdi     # 0x2c33f
leaq 0x22114(%rip), %rsi     # 0x2c34f
movl $0x8e, %edx
leaq 0x2211c(%rip), %rcx     # 0x2c363
callq 0x81a0
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0xa160
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rax
movq 0x20(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl $0x20, %edi
callq 0x8290
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rdx
movq 0x20(%rax), %rcx
movl $0x1, %esi
callq 0xa2f0
jmp 0xa296
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq $0xa, 0x18(%rax)
movl $0xa, %edi
callq 0x8030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nop
// File: yasz24[P]eau2/src/network/./../utils/string.h
// Function: String::equals(Object*)
bool equals(Object* other) {
        if (other == this) return true;
        String* x = dynamic_cast<String *>(other);
        if (x == nullptr) return false;
        if (size_ != x->size_) return false;
        return strncmp(cstr_, x->cstr_, size_) == 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0xa487
movb $0x1, -0x1(%rbp)
jmp 0xa50f
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xa4b6
movq -0x30(%rbp), %rdi
leaq 0x2fc20(%rip), %rsi     # 0x3a0c0
leaq 0x2ff29(%rip), %rdx     # 0x3a3d0
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x38(%rbp)
jmp 0xa4be
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xa4be
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa4d3
movb $0x0, -0x1(%rbp)
jmp 0xa50f
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0xa4eb
movb $0x0, -0x1(%rbp)
jmp 0xa50f
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq 0x10(%rax), %rdx
callq 0x8150
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../utils/string.h
// Function: String::hash_me()
size_t hash_me() {
        size_t hash = 0;
        for (size_t i = 0; i < size_; ++i)
            hash = cstr_[i] + (hash << 6) + (hash << 16) - hash;
        return hash;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0xa5eb
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movsbq (%rax,%rcx), %rax
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
shlq $0x10, %rcx
addq %rcx, %rax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa5a0
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, char*)
void write(const char* name, char* val) {
        int SIZEOFINSERTS = 10;
        char str[strlen(val) + strlen(name) + SIZEOFINSERTS];
        sprintf(str, "'%s' : '%s', ", name, val);
        buff->c(str);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0xa, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8130
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8130
movq -0x48(%rbp), %rdx
addq %rax, %rdx
movslq -0x1c(%rbp), %rcx
movq %rdx, %rax
addq %rcx, %rax
movq %rsp, %rsi
movq %rsi, -0x28(%rbp)
leaq 0xf(%rcx,%rdx), %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rsp
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x21c6b(%rip), %rsi     # 0x2c3d5
movb $0x0, %al
callq 0x8090
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0xa0f0
movq -0x28(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/application.h
// Function: Demo::run_()
void run_() override {
    switch(this_node()) {
    case 0:   producer();     break;
    case 1:   counter();      break;
    case 2:   summarizer();
   }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xca80
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
testq %rax, %rax
je 0xa96f
jmp 0xa957
movq -0x10(%rbp), %rax
subq $0x1, %rax
je 0xa97a
jmp 0xa963
movq -0x10(%rbp), %rax
subq $0x2, %rax
je 0xa985
jmp 0xa98e
movq -0x18(%rbp), %rdi
callq 0xcaa0
jmp 0xa98e
movq -0x18(%rbp), %rdi
callq 0xcba0
jmp 0xa98e
movq -0x18(%rbp), %rdi
callq 0xccb0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop