LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xSetWhiteningSeed
void SX126xSetWhiteningSeed( uint16_t seed )
{
    uint8_t regValue = 0;
    
    switch( SX126xGetPacketType( ) )
    {
        case PACKET_TYPE_GFSK:
            regValue = SX126xReadRegister( REG_LR_WHITSEEDBASEADDR_MSB ) & 0xFE;
            regValue = ( ( seed >> 8 ) & 0x01 ) | regValue;
            SX126xWriteRegister( REG_LR_WHITSEEDBASEADDR_MSB, regValue ); // only 1 bit.
            SX126xWriteRegister( REG_LR_WHITSEEDBASEADDR_LSB, ( uint8_t )seed );
            break;

        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movb $0x0, -0x3(%rbp)
callq 0x5780
testl %eax, %eax
jne 0x5847
jmp 0x57fe
movl $0x6b8, %edi            # imm = 0x6B8
callq 0x7210
movzbl %al, %eax
andl $0xfe, %eax
movb %al, -0x3(%rbp)
movzwl -0x2(%rbp), %eax
sarl $0x8, %eax
andl $0x1, %eax
movzbl -0x3(%rbp), %ecx
orl %ecx, %eax
movb %al, -0x3(%rbp)
movl $0x6b8, %edi            # imm = 0x6B8
movzbl -0x3(%rbp), %esi
callq 0x70f0
movw -0x2(%rbp), %ax
movl $0x6b9, %edi            # imm = 0x6B9
movzbl %al, %esi
callq 0x70f0
jmp 0x5849
jmp 0x5849
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xGetRandom
uint32_t SX126xGetRandom( void )
{
    uint32_t number = 0;
    uint8_t regAnaLna = 0;
    uint8_t regAnaMixer = 0;

    regAnaLna = SX126xReadRegister( REG_ANA_LNA );
    SX126xWriteRegister( REG_ANA_LNA, regAnaLna & ~( 1 << 0 ) );

    regAnaMixer = SX126xReadRegister( REG_ANA_MIXER );
    SX126xWriteRegister( REG_ANA_MIXER, regAnaMixer & ~( 1 << 7 ) );

    // Set radio in continuous reception
    SX126xSetRx( 0xFFFFFF ); // Rx Continuous

    SX126xReadRegisters( RANDOM_NUMBER_GENERATORBASEADDR, ( uint8_t* )&number, 4 );

    SX126xSetStandby( STDBY_RC );

    SX126xWriteRegister( REG_ANA_LNA, regAnaLna );
    SX126xWriteRegister( REG_ANA_MIXER, regAnaMixer );

    return number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movb $0x0, -0x5(%rbp)
movb $0x0, -0x6(%rbp)
movl $0x8e2, %edi            # imm = 0x8E2
callq 0x7210
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
andl $-0x2, %eax
movl $0x8e2, %edi            # imm = 0x8E2
movzbl %al, %esi
callq 0x70f0
movl $0x8e5, %edi            # imm = 0x8E5
callq 0x7210
movb %al, -0x6(%rbp)
movzbl -0x6(%rbp), %eax
andl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
movl $0x8e5, %edi            # imm = 0x8E5
movzbl %al, %esi
callq 0x70f0
movl $0xffffff, %edi         # imm = 0xFFFFFF
callq 0x5900
movl $0x819, %edi            # imm = 0x819
leaq -0x4(%rbp), %rsi
movl $0x4, %edx
callq 0x7120
xorl %edi, %edi
callq 0x5500
movl $0x8e2, %edi            # imm = 0x8E2
movzbl -0x5(%rbp), %esi
callq 0x70f0
movl $0x8e5, %edi            # imm = 0x8E5
movzbl -0x6(%rbp), %esi
callq 0x70f0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xSetRx
void SX126xSetRx( uint32_t timeout )
{
    uint8_t buf[3];

    SX126xSetOperatingMode( MODE_RX );

    SX126xWriteRegister( REG_RX_GAIN, 0x94 ); // default gain

    buf[0] = ( uint8_t )( ( timeout >> 16 ) & 0xFF );
    buf[1] = ( uint8_t )( ( timeout >> 8 ) & 0xFF );
    buf[2] = ( uint8_t )( timeout & 0xFF );
    SX126xWriteCommand( RADIO_SET_RX, buf, 3 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x5, %edi
callq 0x6b30
movl $0x8ac, %edi            # imm = 0x8AC
movl $0x94, %esi
callq 0x70f0
movl -0x4(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0x7(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0x6(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movb %al, -0x5(%rbp)
leaq -0x7(%rbp), %rsi
movl $0x82, %edi
movl $0x3, %edx
callq 0x6d60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xSetSleep
void SX126xSetSleep( SleepParams_t sleepConfig )
{
    SX126xAntSwOff( );

    uint8_t value = ( ( ( uint8_t )sleepConfig.Fields.WarmStart << 2 ) |
                      ( ( uint8_t )sleepConfig.Fields.Reset << 1 ) |
                      ( ( uint8_t )sleepConfig.Fields.WakeUpRTC ) );

    if( sleepConfig.Fields.WarmStart == 0 )
    {
        // Force image calibration
        ImageCalibrated = false;
    }
    SX126xWriteCommand( RADIO_SET_SLEEP, &value, 1 );
    SX126xSetOperatingMode( MODE_SLEEP );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
callq 0x7450
movb -0x1(%rbp), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
shll $0x2, %eax
movb -0x1(%rbp), %cl
shrb %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll %ecx
orl %ecx, %eax
movb -0x1(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, -0x2(%rbp)
movb -0x1(%rbp), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x59c5
movb $0x0, 0x8b03(%rip)      # 0xe4c8
movl $0x84, %edi
leaq -0x2(%rbp), %rsi
movl $0x1, %edx
callq 0x6d60
xorl %edi, %edi
callq 0x6b30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xSetRxDutyCycle
void SX126xSetRxDutyCycle( uint32_t rxTime, uint32_t sleepTime )
{
    uint8_t buf[6];

    buf[0] = ( uint8_t )( ( rxTime >> 16 ) & 0xFF );
    buf[1] = ( uint8_t )( ( rxTime >> 8 ) & 0xFF );
    buf[2] = ( uint8_t )( rxTime & 0xFF );
    buf[3] = ( uint8_t )( ( sleepTime >> 16 ) & 0xFF );
    buf[4] = ( uint8_t )( ( sleepTime >> 8 ) & 0xFF );
    buf[5] = ( uint8_t )( sleepTime & 0xFF );
    SX126xWriteCommand( RADIO_SET_RXDUTYCYCLE, buf, 6 );
    SX126xSetOperatingMode( MODE_RX_DC );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0xe(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0xd(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movb %al, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0xb(%rbp)
movl -0x8(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0xa(%rbp)
movl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, -0x9(%rbp)
leaq -0xe(%rbp), %rsi
movl $0x94, %edi
movl $0x6, %edx
callq 0x6d60
movl $0x6, %edi
callq 0x6b30
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xSetLoRaSymbNumTimeout
void SX126xSetLoRaSymbNumTimeout( uint8_t symbNum )
{
    uint8_t mant = ( ( ( symbNum > SX126X_MAX_LORA_SYMB_NUM_TIMEOUT ) ?
                       SX126X_MAX_LORA_SYMB_NUM_TIMEOUT : 
                       symbNum ) + 1 ) >> 1;
    uint8_t exp  = 0;
    uint8_t reg  = 0;

    while( mant > 31 )
    {
        mant = ( mant + 3 ) >> 2;
        exp++;
    }

    reg = mant << ( 2 * exp + 1 );
    SX126xWriteCommand( RADIO_SET_LORASYMBTIMEOUT, &reg, 1 );

    if( symbNum != 0 )
    {
        reg = exp + ( mant << 3 );
        SX126xWriteRegister( REG_LR_SYNCH_TIMEOUT, reg );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0xf8, %eax
jle 0x5bb3
movl $0xf8, %eax
movl %eax, -0x8(%rbp)
jmp 0x5bba
movzbl -0x1(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
sarl %eax
movb %al, -0x2(%rbp)
movb $0x0, -0x3(%rbp)
movb $0x0, -0x4(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x1f, %eax
jle 0x5bed
movzbl -0x2(%rbp), %eax
addl $0x3, %eax
sarl $0x2, %eax
movb %al, -0x2(%rbp)
movb -0x3(%rbp), %al
addb $0x1, %al
movb %al, -0x3(%rbp)
jmp 0x5bcd
movzbl -0x2(%rbp), %eax
movzbl -0x3(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
shll %cl, %eax
movb %al, -0x4(%rbp)
movl $0xa0, %edi
leaq -0x4(%rbp), %rsi
movl $0x1, %edx
callq 0x6d60
movzbl -0x1(%rbp), %eax
cmpl $0x0, %eax
je 0x5c39
movzbl -0x3(%rbp), %eax
movzbl -0x2(%rbp), %ecx
shll $0x3, %ecx
addl %ecx, %eax
movb %al, -0x4(%rbp)
movl $0x706, %edi            # imm = 0x706
movzbl -0x4(%rbp), %esi
callq 0x70f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xCalibrate
void SX126xCalibrate( CalibrationParams_t calibParam )
{
    uint8_t value = ( ( ( uint8_t )calibParam.Fields.ImgEnable << 6 ) |
                      ( ( uint8_t )calibParam.Fields.ADCBulkPEnable << 5 ) |
                      ( ( uint8_t )calibParam.Fields.ADCBulkNEnable << 4 ) |
                      ( ( uint8_t )calibParam.Fields.ADCPulseEnable << 3 ) |
                      ( ( uint8_t )calibParam.Fields.PLLEnable << 2 ) |
                      ( ( uint8_t )calibParam.Fields.RC13MEnable << 1 ) |
                      ( ( uint8_t )calibParam.Fields.RC64KEnable ) );

    SX126xWriteCommand( RADIO_CALIBRATE, &value, 1 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
shrb $0x6, %al
andb $0x1, %al
movzbl %al, %eax
shll $0x6, %eax
movb -0x1(%rbp), %cl
shrb $0x5, %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll $0x5, %ecx
orl %ecx, %eax
movb -0x1(%rbp), %cl
shrb $0x4, %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll $0x4, %ecx
orl %ecx, %eax
movb -0x1(%rbp), %cl
shrb $0x3, %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll $0x3, %ecx
orl %ecx, %eax
movb -0x1(%rbp), %cl
shrb $0x2, %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll $0x2, %ecx
orl %ecx, %eax
movb -0x1(%rbp), %cl
shrb %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll %ecx
orl %ecx, %eax
movb -0x1(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, -0x2(%rbp)
movl $0x89, %edi
leaq -0x2(%rbp), %rsi
movl $0x1, %edx
callq 0x6d60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xCalibrateImage
void SX126xCalibrateImage( uint32_t freq )
{
    uint8_t calFreq[2];

    if( freq > 900000000 )
    {
        calFreq[0] = 0xE1;
        calFreq[1] = 0xE9;
    }
    else if( freq > 850000000 )
    {
        calFreq[0] = 0xD7;
        calFreq[1] = 0xDB;
    }
    else if( freq > 770000000 )
    {
        calFreq[0] = 0xC1;
        calFreq[1] = 0xC5;
    }
    else if( freq > 460000000 )
    {
        calFreq[0] = 0x75;
        calFreq[1] = 0x81;
    }
    else if( freq > 425000000 )
    {
        calFreq[0] = 0x6B;
        calFreq[1] = 0x6F;
    }
    SX126xWriteCommand( RADIO_CALIBRATEIMAGE, calFreq, 2 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x35a4e900, -0x4(%rbp) # imm = 0x35A4E900
jbe 0x5d2e
movb $-0x1f, -0x6(%rbp)
movb $-0x17, -0x5(%rbp)
jmp 0x5d80
cmpl $0x32a9f880, -0x4(%rbp) # imm = 0x32A9F880
jbe 0x5d41
movb $-0x29, -0x6(%rbp)
movb $-0x25, -0x5(%rbp)
jmp 0x5d7e
cmpl $0x2de54480, -0x4(%rbp) # imm = 0x2DE54480
jbe 0x5d54
movb $-0x3f, -0x6(%rbp)
movb $-0x3b, -0x5(%rbp)
jmp 0x5d7c
cmpl $0x1b6b0b00, -0x4(%rbp) # imm = 0x1B6B0B00
jbe 0x5d67
movb $0x75, -0x6(%rbp)
movb $-0x7f, -0x5(%rbp)
jmp 0x5d7a
cmpl $0x1954fc40, -0x4(%rbp) # imm = 0x1954FC40
jbe 0x5d78
movb $0x6b, -0x6(%rbp)
movb $0x6f, -0x5(%rbp)
jmp 0x5d7a
jmp 0x5d7c
jmp 0x5d7e
jmp 0x5d80
leaq -0x6(%rbp), %rsi
movl $0x98, %edi
movl $0x2, %edx
callq 0x6d60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xSetPaConfig
void SX126xSetPaConfig( uint8_t paDutyCycle, uint8_t hpMax, uint8_t deviceSel, uint8_t paLut )
{
	printf("SX126xSetPaConfig: paDutyCycle=%d, hpMax=%d, deviceSel=%d, paLut=%d \r\n", (int) paDutyCycle, (int) hpMax, (int) deviceSel, (int) paLut);
    uint8_t buf[4];

    buf[0] = paDutyCycle;
    buf[1] = hpMax;
    buf[2] = deviceSel;
    buf[3] = paLut;
    SX126xWriteCommand( RADIO_SET_PACONFIG, buf, 4 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movb %dil, %sil
movb %sil, -0x1(%rbp)
movb %dl, -0x2(%rbp)
movb %cl, -0x3(%rbp)
movb %al, -0x4(%rbp)
movzbl -0x1(%rbp), %esi
movzbl -0x2(%rbp), %edx
movzbl -0x3(%rbp), %ecx
movzbl -0x4(%rbp), %r8d
leaq 0x38d3(%rip), %rdi      # 0x96aa
movb $0x0, %al
callq 0x2050
movb -0x1(%rbp), %al
movb %al, -0x8(%rbp)
movb -0x2(%rbp), %al
movb %al, -0x7(%rbp)
movb -0x3(%rbp), %al
movb %al, -0x6(%rbp)
movb -0x4(%rbp), %al
movb %al, -0x5(%rbp)
leaq -0x8(%rbp), %rsi
movl $0x95, %edi
movl $0x4, %edx
callq 0x6d60
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xSetDioIrqParams
void SX126xSetDioIrqParams( uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask, uint16_t dio3Mask )
{
    uint8_t buf[8];

    buf[0] = ( uint8_t )( ( irqMask >> 8 ) & 0x00FF );
    buf[1] = ( uint8_t )( irqMask & 0x00FF );
    buf[2] = ( uint8_t )( ( dio1Mask >> 8 ) & 0x00FF );
    buf[3] = ( uint8_t )( dio1Mask & 0x00FF );
    buf[4] = ( uint8_t )( ( dio2Mask >> 8 ) & 0x00FF );
    buf[5] = ( uint8_t )( dio2Mask & 0x00FF );
    buf[6] = ( uint8_t )( ( dio3Mask >> 8 ) & 0x00FF );
    buf[7] = ( uint8_t )( dio3Mask & 0x00FF );
    SX126xWriteCommand( RADIO_CFG_DIOIRQ, buf, 8 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %cx, %ax
movw %dx, %cx
movw %si, %dx
movw %di, %si
movw %si, -0x2(%rbp)
movw %dx, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movzwl -0x2(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
andl $0xff, %eax
movb %al, -0xf(%rbp)
movzwl -0x4(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0xe(%rbp)
movzwl -0x4(%rbp), %eax
andl $0xff, %eax
movb %al, -0xd(%rbp)
movzwl -0x6(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0xc(%rbp)
movzwl -0x6(%rbp), %eax
andl $0xff, %eax
movb %al, -0xb(%rbp)
movzwl -0x8(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0xa(%rbp)
movzwl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, -0x9(%rbp)
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
movl %edx, %edi
callq 0x6d60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xSetDio3AsTcxoCtrl
void SX126xSetDio3AsTcxoCtrl( RadioTcxoCtrlVoltage_t tcxoVoltage, uint32_t timeout )
{
    uint8_t buf[4];

    buf[0] = tcxoVoltage & 0x07;
    buf[1] = ( uint8_t )( ( timeout >> 16 ) & 0xFF );
    buf[2] = ( uint8_t )( ( timeout >> 8 ) & 0xFF );
    buf[3] = ( uint8_t )( timeout & 0xFF );

    SX126xWriteCommand( RADIO_SET_TCXOMODE, buf, 4 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x7, %eax
movb %al, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0xb(%rbp)
movl -0x8(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0xa(%rbp)
movl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, -0x9(%rbp)
leaq -0xc(%rbp), %rsi
movl $0x97, %edi
movl $0x4, %edx
callq 0x6d60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xSetRfFrequency
void SX126xSetRfFrequency( uint32_t frequency )
{
    uint8_t buf[4];

    if( ImageCalibrated == false )
    {
        SX126xCalibrateImage( frequency );
        ImageCalibrated = true;
    }

    uint32_t freqInPllSteps = SX126xConvertFreqInHzToPllStep( frequency );

    buf[0] = ( uint8_t )( ( freqInPllSteps >> 24 ) & 0xFF );
    buf[1] = ( uint8_t )( ( freqInPllSteps >> 16 ) & 0xFF );
    buf[2] = ( uint8_t )( ( freqInPllSteps >> 8 ) & 0xFF );
    buf[3] = ( uint8_t )( freqInPllSteps & 0xFF );
    SX126xWriteCommand( RADIO_SET_RFFREQUENCY, buf, 4 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movb 0x8507(%rip), %al       # 0xe4c8
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5fda
movl -0x4(%rbp), %edi
callq 0x5d10
movb $0x1, 0x84ee(%rip)      # 0xe4c8
movl -0x4(%rbp), %edi
callq 0x6040
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, -0x8(%rbp)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0x7(%rbp)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0x6(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, -0x5(%rbp)
leaq -0x8(%rbp), %rsi
movl $0x86, %edi
movl $0x4, %edx
callq 0x6d60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xConvertFreqInHzToPllStep
static uint32_t SX126xConvertFreqInHzToPllStep( uint32_t freqInHz )
{
    uint32_t stepsInt;
    uint32_t stepsFrac;

    // pllSteps = freqInHz / (SX126X_XTAL_FREQ / 2^19 )
    // Get integer and fractional parts of the frequency computed with a PLL step scaled value
    stepsInt = freqInHz / SX126X_PLL_STEP_SCALED;
    stepsFrac = freqInHz - ( stepsInt * SX126X_PLL_STEP_SCALED );
    
    // Apply the scaling factor to retrieve a frequency in Hz (+ ceiling)
    return ( stepsInt << SX126X_PLL_STEP_SHIFT_AMOUNT ) + 
           ( ( ( stepsFrac << SX126X_PLL_STEP_SHIFT_AMOUNT ) + ( SX126X_PLL_STEP_SCALED >> 1 ) ) /
             SX126X_PLL_STEP_SCALED );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0x3d09, %ecx           # imm = 0x3D09
xorl %edx, %edx
divq %rcx
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
imulq $0x3d09, %rcx, %rcx     # imm = 0x3D09
subq %rcx, %rax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0xe, %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
shll $0xe, %eax
movl %eax, %eax
addq $0x1e84, %rax           # imm = 0x1E84
movl $0x3d09, %ecx           # imm = 0x3D09
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xSetTxParams
void SX126xSetTxParams( int8_t power, RadioRampTimes_t rampTime )
{
    printf("SX126xSetTxParams: power=%d, rampTime=%d\r\n", (int) power, (int) rampTime);
    uint8_t buf[2];

    if( SX126xGetDeviceId( ) == SX1261 )
    {
        if( power == 15 )
        {
            SX126xSetPaConfig( 0x06, 0x00, 0x01, 0x01 );
        }
        else
        {
            SX126xSetPaConfig( 0x04, 0x00, 0x01, 0x01 );
        }
        if( power >= 14 )
        {
            power = 14;
        }
        else if( power < -17 )
        {
            power = -17;
        }
        ////  TODO: Set the current max value in the over current protection. From SX126x-Arduino/src/radio/sx126x/sx126x.cpp
		SX126xWriteRegister(REG_OCP, 0x18); // current max is 80 mA for the whole device
    }
    else // sx1262
    {
        // WORKAROUND - Better Resistance of the SX1262 Tx to Antenna Mismatch, see DS_SX1261-2_V1.2 datasheet chapter 15.2
        SX126xWriteRegister( REG_TX_CLAMP_CFG, SX126xReadRegister( REG_TX_CLAMP_CFG ) | ( 0x0F << 1 ) );
        // WORKAROUND END

        SX126xSetPaConfig( 0x04, 0x07, 0x00, 0x01 );
        if( power > 22 )
        {
            power = 22;
        }
        else if( power < -9 )
        {
            power = -9;
        }

        ////  TODO: Set the current max value in the over current protection. From SX126x-Arduino/src/radio/sx126x/sx126x.cpp
        SX126xWriteRegister(REG_OCP, 0x38); // current max 160mA for the whole device
    }
    buf[0] = power;
    buf[1] = ( uint8_t )rampTime;
    SX126xWriteCommand( RADIO_SET_TXPARAMS, buf, 2 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movsbl -0x1(%rbp), %esi
movl -0x8(%rbp), %edx
leaq 0x3602(%rip), %rdi      # 0x96f1
movb $0x0, %al
callq 0x2050
callq 0x7420
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x6163
movsbl -0x1(%rbp), %eax
cmpl $0xf, %eax
jne 0x6121
movl $0x6, %edi
xorl %esi, %esi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x5da0
jmp 0x6134
movl $0x4, %edi
xorl %esi, %esi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x5da0
movsbl -0x1(%rbp), %eax
cmpl $0xe, %eax
jl 0x6143
movb $0xe, -0x1(%rbp)
jmp 0x6152
movsbl -0x1(%rbp), %eax
cmpl $-0x11, %eax
jge 0x6150
movb $-0x11, -0x1(%rbp)
jmp 0x6152
movl $0x8e7, %edi            # imm = 0x8E7
movl $0x18, %esi
callq 0x70f0
jmp 0x61c3
movl $0x8d8, %edi            # imm = 0x8D8
callq 0x7210
movzbl %al, %eax
orl $0x1e, %eax
movl $0x8d8, %edi            # imm = 0x8D8
movzbl %al, %esi
callq 0x70f0
movl $0x4, %edi
movl $0x7, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x5da0
movsbl -0x1(%rbp), %eax
cmpl $0x16, %eax
jle 0x61a5
movb $0x16, -0x1(%rbp)
jmp 0x61b4
movsbl -0x1(%rbp), %eax
cmpl $-0x9, %eax
jge 0x61b2
movb $-0x9, -0x1(%rbp)
jmp 0x61b4
movl $0x8e7, %edi            # imm = 0x8E7
movl $0x38, %esi
callq 0x70f0
movb -0x1(%rbp), %al
movb %al, -0xa(%rbp)
movl -0x8(%rbp), %eax
movb %al, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movl $0x8e, %edi
movl $0x2, %edx
callq 0x6d60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xSetCadParams
void SX126xSetCadParams( RadioLoRaCadSymbols_t cadSymbolNum, uint8_t cadDetPeak, uint8_t cadDetMin, RadioCadExitModes_t cadExitMode, uint32_t cadTimeout )
{
    uint8_t buf[7];

    buf[0] = ( uint8_t )cadSymbolNum;
    buf[1] = cadDetPeak;
    buf[2] = cadDetMin;
    buf[3] = ( uint8_t )cadExitMode;
    buf[4] = ( uint8_t )( ( cadTimeout >> 16 ) & 0xFF );
    buf[5] = ( uint8_t )( ( cadTimeout >> 8 ) & 0xFF );
    buf[6] = ( uint8_t )( cadTimeout & 0xFF );
    SX126xWriteCommand( RADIO_SET_CADPARAMS, buf, 7 );
    SX126xSetOperatingMode( MODE_CAD );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %dl
movl %edi, -0x4(%rbp)
movb %dl, -0x5(%rbp)
movb %al, -0x6(%rbp)
movl %ecx, -0xc(%rbp)
movl %r8d, -0x10(%rbp)
movl -0x4(%rbp), %eax
movb %al, -0x17(%rbp)
movb -0x5(%rbp), %al
movb %al, -0x16(%rbp)
movb -0x6(%rbp), %al
movb %al, -0x15(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0x14(%rbp)
movl -0x10(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0x13(%rbp)
movl -0x10(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0x12(%rbp)
movl -0x10(%rbp), %eax
andl $0xff, %eax
movb %al, -0x11(%rbp)
leaq -0x17(%rbp), %rsi
movl $0x88, %edi
movl $0x7, %edx
callq 0x6d60
movl $0x7, %edi
callq 0x6b30
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xGetStatus
RadioStatus_t SX126xGetStatus( void )
{
    uint8_t stat = 0;
    RadioStatus_t status = { .Value = 0 };

    stat = SX126xReadCommand( RADIO_GET_STATUS, NULL, 0 );
    status.Fields.CmdStatus = ( stat & ( 0x07 << 1 ) ) >> 1;
    status.Fields.ChipMode = ( stat & ( 0x07 << 4 ) ) >> 4;
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, -0x2(%rbp)
leaq -0x1(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2100
movl $0xc0, %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x6de0
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
andl $0xe, %eax
sarl %eax
movb %al, %cl
movb -0x1(%rbp), %al
andb $0x7, %cl
shlb %cl
andb $-0xf, %al
orb %cl, %al
movb %al, -0x1(%rbp)
movzbl -0x2(%rbp), %eax
andl $0x70, %eax
sarl $0x4, %eax
movb %al, %cl
movb -0x1(%rbp), %al
andb $0x7, %cl
shlb $0x4, %cl
andb $-0x71, %al
orb %cl, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xGetRssiInst
int8_t SX126xGetRssiInst( void )
{
    uint8_t buf[1];
    int8_t rssi = 0;

    SX126xReadCommand( RADIO_GET_RSSIINST, buf, 1 );
    rssi = -buf[0] >> 1;
    return rssi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, -0x2(%rbp)
leaq -0x1(%rbp), %rsi
movl $0x15, %edi
movl $0x1, %edx
callq 0x6de0
movzbl -0x1(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
sarl %eax
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xGetPacketStatus
void SX126xGetPacketStatus( PacketStatus_t *pktStatus )
{
    uint8_t status[3];

    SX126xReadCommand( RADIO_GET_PACKETSTATUS, status, 3 );

    pktStatus->packetType = SX126xGetPacketType( );
    switch( pktStatus->packetType )
    {
        case PACKET_TYPE_GFSK:
            pktStatus->Params.Gfsk.RxStatus = status[0];
            pktStatus->Params.Gfsk.RssiSync = -status[1] >> 1;
            pktStatus->Params.Gfsk.RssiAvg = -status[2] >> 1;
            pktStatus->Params.Gfsk.FreqError = 0;
            break;

        case PACKET_TYPE_LORA:
            pktStatus->Params.LoRa.RssiPkt = -status[0] >> 1;
            // Returns SNR value [dB] rounded to the nearest integer value
            pktStatus->Params.LoRa.SnrPkt = ( ( ( int8_t )status[1] ) + 2 ) >> 2;
            pktStatus->Params.LoRa.SignalRssiPkt = -status[2] >> 1;
            pktStatus->Params.LoRa.FreqError = FrequencyError;
            break;

        default:
        case PACKET_TYPE_NONE:
            // In that specific case, we set everything in the pktStatus to zeros
            // and reset the packet type accordingly
            memset( pktStatus, 0, sizeof( PacketStatus_t ) );
            pktStatus->packetType = PACKET_TYPE_NONE;
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x14, %edi
leaq -0xb(%rbp), %rsi
movl $0x3, %edx
callq 0x6de0
callq 0x5780
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x66b6
jmp 0x669b
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x66f3
jmp 0x66a5
movl -0x10(%rbp), %eax
subl $0xf, %eax
je 0x673d
jmp 0x673b
movb -0xb(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4(%rax)
movzbl -0xa(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
sarl %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x6(%rax)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
sarl %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x6757
movzbl -0xb(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
sarl %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xc(%rax)
movsbl -0xa(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xd(%rax)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
sarl %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xe(%rax)
movl 0x7d92(%rip), %ecx      # 0xe4c4
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x6757
jmp 0x673d
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x2100
movq -0x8(%rbp), %rax
movl $0xf, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x.c
// Function: SX126xGetDeviceErrors
RadioError_t SX126xGetDeviceErrors( void )
{
    uint8_t err[] = { 0, 0 };
    RadioError_t error = { .Value = 0 };

    SX126xReadCommand( RADIO_GET_ERROR, ( uint8_t* )err, 2 );
    error.Fields.PaRamp     = ( err[0] & ( 1 << 0 ) ) >> 0;
    error.Fields.PllLock    = ( err[1] & ( 1 << 6 ) ) >> 6;
    error.Fields.XoscStart  = ( err[1] & ( 1 << 5 ) ) >> 5;
    error.Fields.ImgCalib   = ( err[1] & ( 1 << 4 ) ) >> 4;
    error.Fields.AdcCalib   = ( err[1] & ( 1 << 3 ) ) >> 3;
    error.Fields.PllCalib   = ( err[1] & ( 1 << 2 ) ) >> 2;
    error.Fields.Rc13mCalib = ( err[1] & ( 1 << 1 ) ) >> 1;
    error.Fields.Rc64kCalib = ( err[1] & ( 1 << 0 ) ) >> 0;
    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2100
leaq -0x2(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2100
leaq -0x4(%rbp), %rsi
movl $0x17, %edi
movl $0x2, %edx
callq 0x6de0
movzbl -0x4(%rbp), %eax
andl $0x1, %eax
sarl $0x0, %eax
movzbl %al, %eax
movw %ax, %cx
movw -0x2(%rbp), %ax
andw $0x1, %cx
shlw $0x8, %cx
andw $0xfeff, %ax            # imm = 0xFEFF
orw %cx, %ax
movw %ax, -0x2(%rbp)
movzbl -0x3(%rbp), %eax
andl $0x40, %eax
sarl $0x6, %eax
movzbl %al, %eax
movw %ax, %cx
movw -0x2(%rbp), %ax
andw $0x1, %cx
shlw $0x6, %cx
andw $-0x41, %ax
orw %cx, %ax
movw %ax, -0x2(%rbp)
movzbl -0x3(%rbp), %eax
andl $0x20, %eax
sarl $0x5, %eax
movzbl %al, %eax
movw %ax, %cx
movw -0x2(%rbp), %ax
andw $0x1, %cx
shlw $0x5, %cx
andw $-0x21, %ax
orw %cx, %ax
movw %ax, -0x2(%rbp)
movzbl -0x3(%rbp), %eax
andl $0x10, %eax
sarl $0x4, %eax
movzbl %al, %eax
movw %ax, %cx
movw -0x2(%rbp), %ax
andw $0x1, %cx
shlw $0x4, %cx
andw $-0x11, %ax
orw %cx, %ax
movw %ax, -0x2(%rbp)
movzbl -0x3(%rbp), %eax
andl $0x8, %eax
sarl $0x3, %eax
movzbl %al, %eax
movw %ax, %cx
movw -0x2(%rbp), %ax
andw $0x1, %cx
shlw $0x3, %cx
andw $-0x9, %ax
orw %cx, %ax
movw %ax, -0x2(%rbp)
movzbl -0x3(%rbp), %eax
andl $0x4, %eax
sarl $0x2, %eax
movzbl %al, %eax
movw %ax, %cx
movw -0x2(%rbp), %ax
andw $0x1, %cx
shlw $0x2, %cx
andw $-0x5, %ax
orw %cx, %ax
movw %ax, -0x2(%rbp)
movzbl -0x3(%rbp), %eax
andl $0x2, %eax
sarl %eax
movzbl %al, %eax
movw %ax, %cx
movw -0x2(%rbp), %ax
andw $0x1, %cx
shlw %cx
andw $-0x3, %ax
orw %cx, %ax
movw %ax, -0x2(%rbp)
movzbl -0x3(%rbp), %eax
andl $0x1, %eax
sarl $0x0, %eax
movzbl %al, %eax
movw %ax, %cx
movw -0x2(%rbp), %ax
andw $0x1, %cx
andw $-0x2, %ax
orw %cx, %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: init_spi
static int init_spi(void) {
    //  Open the SPI Bus
    spi = open("/dev/spidev1.0", O_RDWR);
    assert(spi > 0);

    //  Set to SPI Mode 0
    uint8_t mmode = SPI_MODE_0;
    int rc = ioctl(spi, SPI_IOC_WR_MODE, &mmode);
    assert(rc == 0);

    //  Set LSB/MSB Mode
    uint8_t lsb = 0;
    rc = ioctl(spi, SPI_IOC_WR_LSB_FIRST, &lsb);
    assert(rc == 0);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x32e8(%rip), %rdi      # 0x9ca7
movl $0x2, %esi
movb $0x0, %al
callq 0x2140
movl %eax, 0x831f(%rip)      # 0xecf0
cmpl $0x0, 0x8318(%rip)      # 0xecf0
jle 0x69dc
jmp 0x69fb
leaq 0x31b1(%rip), %rdi      # 0x9b94
leaq 0x2d49(%rip), %rsi      # 0x9733
movl $0x28f, %edx            # imm = 0x28F
leaq 0x32c0(%rip), %rcx      # 0x9cb6
callq 0x2130
movb $0x0, -0x1(%rbp)
movl 0x82eb(%rip), %edi      # 0xecf0
movl $0x40016b01, %esi       # imm = 0x40016B01
leaq -0x1(%rbp), %rdx
movb $0x0, %al
callq 0x2220
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x6a20
jmp 0x6a3f
leaq 0x2d04(%rip), %rdi      # 0x972b
leaq 0x2d05(%rip), %rsi      # 0x9733
movl $0x294, %edx            # imm = 0x294
leaq 0x327c(%rip), %rcx      # 0x9cb6
callq 0x2130
movb $0x0, -0x9(%rbp)
movl 0x82a7(%rip), %edi      # 0xecf0
movl $0x40016b02, %esi       # imm = 0x40016B02
leaq -0x9(%rbp), %rdx
movb $0x0, %al
callq 0x2220
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x6a64
jmp 0x6a83
leaq 0x2cc0(%rip), %rdi      # 0x972b
leaq 0x2cc1(%rip), %rsi      # 0x9733
movl $0x299, %edx            # imm = 0x299
leaq 0x3238(%rip), %rcx      # 0x9cb6
callq 0x2130
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: SX126xWakeup
void SX126xWakeup( void )
{
    printf("SX126xWakeup\r\n");
    CRITICAL_SECTION_BEGIN( );

    // Write RADIO_GET_STATUS command followed by 0
    uint8_t commands[1] = { RADIO_GET_STATUS };
    uint8_t buffer[1]   = { 0 };
    int rc = sx126x_hal_write(NULL, commands, sizeof(commands), buffer, sizeof(buffer));
    assert(rc == 0);

    // Wait for chip to be ready.
    SX126xWaitOnBusy( );

    // Update operating mode context variable
    SX126xSetOperatingMode( MODE_STDBY_RC );

    CRITICAL_SECTION_END( );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2c1b(%rip), %rdi      # 0x97ba
movb $0x0, %al
callq 0x2050
movb 0x311d(%rip), %al       # 0x9cc9
movb %al, -0x1(%rbp)
leaq -0x2(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2100
leaq -0x1(%rbp), %rsi
leaq -0x2(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %r8d
movl %r8d, %edx
callq 0x6c20
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x6be4
jmp 0x6c03
leaq 0x2b40(%rip), %rdi      # 0x972b
leaq 0x2b41(%rip), %rsi      # 0x9733
movl $0xc1, %edx
leaq 0x2bcb(%rip), %rcx      # 0x97c9
callq 0x2130
callq 0x6b70
movl $0x1, %edi
callq 0x6b30
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: sx126x_hal_write
static int sx126x_hal_write( 
    const void* context, const uint8_t* command, const uint16_t command_length,
    const uint8_t* data, const uint16_t data_length ) {
    printf("sx126x_hal_write: command_length=%d, data_length=%d\n", command_length, data_length);

    //  Total length is command + data length
    uint16_t len = command_length + data_length;
    assert(len > 0);
    assert(len <= SPI_BUFFER_SIZE);

    //  Clear the SPI Transmit and Receive buffers
    memset(&spi_tx_buf, 0, len);
    memset(&spi_rx_buf, 0, len);

    //  Copy command bytes to SPI Transmit Buffer
    memcpy(&spi_tx_buf, command, command_length);

    //  Copy data bytes to SPI Transmit Buffer
    memcpy(&spi_tx_buf[command_length], data, data_length);

    //  Transmit and receive the SPI buffers
    int rc = transfer_spi(spi_tx_buf, spi_rx_buf, len);
    assert(rc == 0);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %dx, -0x12(%rbp)
movq %rcx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movzwl -0x12(%rbp), %esi
movzwl -0x22(%rbp), %edx
leaq 0x2e8c(%rip), %rdi      # 0x9adb
movb $0x0, %al
callq 0x2050
movzwl -0x12(%rbp), %eax
movzwl -0x22(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0x24(%rbp)
movzwl -0x24(%rbp), %eax
cmpl $0x0, %eax
jle 0x6c6f
jmp 0x6c8e
leaq 0x2e9a(%rip), %rdi      # 0x9b10
leaq 0x2ab6(%rip), %rsi      # 0x9733
movl $0x228, %edx            # imm = 0x228
leaq 0x2e8f(%rip), %rcx      # 0x9b18
callq 0x2130
movzwl -0x24(%rbp), %eax
cmpl $0x400, %eax            # imm = 0x400
jg 0x6c9b
jmp 0x6cba
leaq 0x2edb(%rip), %rdi      # 0x9b7d
leaq 0x2a8a(%rip), %rsi      # 0x9733
movl $0x229, %edx            # imm = 0x229
leaq 0x2e63(%rip), %rcx      # 0x9b18
callq 0x2130
movzwl -0x24(%rbp), %eax
movl %eax, %edx
leaq 0x7829(%rip), %rdi      # 0xe4f0
xorl %esi, %esi
callq 0x2100
movzwl -0x24(%rbp), %eax
movl %eax, %edx
leaq 0x7c15(%rip), %rdi      # 0xe8f0
xorl %esi, %esi
callq 0x2100
movq -0x10(%rbp), %rsi
movzwl -0x12(%rbp), %eax
movl %eax, %edx
leaq 0x77fd(%rip), %rdi      # 0xe4f0
callq 0x2180
movzwl -0x12(%rbp), %eax
leaq 0x77ed(%rip), %rdi      # 0xe4f0
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movzwl -0x22(%rbp), %eax
movl %eax, %edx
callq 0x2180
leaq 0x77d4(%rip), %rdi      # 0xe4f0
leaq 0x7bcd(%rip), %rsi      # 0xe8f0
movzwl -0x24(%rbp), %edx
callq 0x76c0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x6d37
jmp 0x6d56
leaq 0x29ed(%rip), %rdi      # 0x972b
leaq 0x29ee(%rip), %rsi      # 0x9733
movl $0x237, %edx            # imm = 0x237
leaq 0x2dc7(%rip), %rcx      # 0x9b18
callq 0x2130
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: SX126xWriteCommand
void SX126xWriteCommand( RadioCommands_t command, uint8_t *buffer, uint16_t size )
{
    SX126xCheckDeviceReady( );

    //  Write the command followed by buffer
    uint8_t commands[1] = { (uint8_t) command };
    int rc = sx126x_hal_write(NULL, commands, sizeof(commands), buffer, size);
    assert(rc == 0);

    if( command != RADIO_SET_SLEEP )
    {
        SX126xWaitOnBusy( );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
callq 0x5540
movl -0x4(%rbp), %eax
movb %al, -0x13(%rbp)
leaq -0x13(%rbp), %rsi
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %edx
movzwl -0x12(%rbp), %r8d
callq 0x6c20
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x6da7
jmp 0x6dc6
leaq 0x297d(%rip), %rdi      # 0x972b
leaq 0x297e(%rip), %rsi      # 0x9733
movl $0xd3, %edx
leaq 0x2a20(%rip), %rcx      # 0x97e1
callq 0x2130
cmpl $0x84, -0x4(%rbp)
je 0x6dd4
callq 0x6b70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: SX126xReadCommand
uint8_t SX126xReadCommand( RadioCommands_t command, uint8_t *buffer, uint16_t size )
{
    printf("SX126xReadCommand: command=0x%02x, size=%d\r\n", command, size);
    uint8_t status = 0;

    SX126xCheckDeviceReady( );

    //  Write the command, read the status and read the buffer
    uint8_t commandStatus[2] = { 
        (uint8_t) command,  //  Command
        0                   //  Status
    };
    int rc = sx126x_hal_read(NULL, commandStatus, sizeof(commandStatus), buffer, size, &status);
    assert(rc == 0);
    printf("status=0x%02x\n", status);

#ifdef NOTUSED  //  Previously...
    bl_gpio_output_set( SX126X_SPI_CS_PIN, 0 );
    if (SX126X_DEBUG_CS_PIN >= 0) { bl_gpio_output_set( SX126X_DEBUG_CS_PIN, 0 ); }

    SpiInOut( SX126X_SPI_IDX, ( uint8_t )command );
    status = SpiInOut( SX126X_SPI_IDX, 0x00 );
    for( uint16_t i = 0; i < size; i++ )
    {
        buffer[i] = SpiInOut( SX126X_SPI_IDX, 0 );
    }

    bl_gpio_output_set( SX126X_SPI_CS_PIN, 1 );
    if (SX126X_DEBUG_CS_PIN >= 0) { bl_gpio_output_set( SX126X_DEBUG_CS_PIN, 1 ); }
#endif  //  NOTUSED

    SX126xWaitOnBusy( );

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl -0x4(%rbp), %esi
movzwl -0x12(%rbp), %edx
leaq 0x2a1b(%rip), %rdi      # 0x981f
movb $0x0, %al
callq 0x2050
movb $0x0, -0x13(%rbp)
callq 0x5540
movl -0x4(%rbp), %eax
movb %al, -0x15(%rbp)
movb $0x0, -0x14(%rbp)
leaq -0x15(%rbp), %rsi
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %edx
leaq -0x13(%rbp), %r9
movzwl -0x12(%rbp), %r8d
callq 0x6e90
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x6e48
jmp 0x6e67
leaq 0x28dc(%rip), %rdi      # 0x972b
leaq 0x28dd(%rip), %rsi      # 0x9733
movl $0xe8, %edx
leaq 0x29ea(%rip), %rcx      # 0x984c
callq 0x2130
movzbl -0x13(%rbp), %esi
leaq 0x2a1a(%rip), %rdi      # 0x988c
movb $0x0, %al
callq 0x2050
callq 0x6b70
movb -0x13(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: SX126xWriteRegisters
void SX126xWriteRegisters( uint16_t address, uint8_t *buffer, uint16_t size )
{
    SX126xCheckDeviceReady( );
    int rc = sx126x_write_register(NULL, address, buffer, size);
    assert(rc == 0);
    SX126xWaitOnBusy( );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
callq 0x5540
movw -0x2(%rbp), %cx
movq -0x10(%rbp), %rdx
movw -0x12(%rbp), %ax
xorl %esi, %esi
movl %esi, %edi
movzwl %cx, %esi
movzbl %al, %ecx
callq 0x7080
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x7055
jmp 0x7074
leaq 0x26cf(%rip), %rdi      # 0x972b
leaq 0x26d0(%rip), %rsi      # 0x9733
movl $0x103, %edx            # imm = 0x103
leaq 0x282c(%rip), %rcx      # 0x989b
callq 0x2130
callq 0x6b70
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: sx126x_write_register
static int sx126x_write_register( const void* context, const uint16_t address, const uint8_t* buffer,
    const uint8_t size ) {
    uint8_t buf[SX126X_SIZE_WRITE_REGISTER] = { 0 };
    buf[0] = RADIO_WRITE_REGISTER;
    buf[1] = ( uint8_t )( address >> 8 );
    buf[2] = ( uint8_t )( address >> 0 );
    return sx126x_hal_write( context, buf, SX126X_SIZE_WRITE_REGISTER, buffer, size );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x2100
movb $0xd, -0x1c(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x8, %eax
movb %al, -0x1b(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x0, %eax
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movq -0x18(%rbp), %rcx
movzbl -0x19(%rbp), %eax
movl $0x3, %edx
movzwl %ax, %r8d
callq 0x6c20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: SX126xReadRegisters
void SX126xReadRegisters( uint16_t address, uint8_t *buffer, uint16_t size )
{
    SX126xCheckDeviceReady( );
    int rc = sx126x_read_register(NULL, address, buffer, size);
    assert(rc == 0);
    SX126xWaitOnBusy( );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
callq 0x5540
movw -0x2(%rbp), %cx
movq -0x10(%rbp), %rdx
movw -0x12(%rbp), %ax
xorl %esi, %esi
movl %esi, %edi
movzwl %cx, %esi
movzbl %al, %ecx
callq 0x7190
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x7165
jmp 0x7184
leaq 0x25bf(%rip), %rdi      # 0x972b
leaq 0x25c0(%rip), %rsi      # 0x9733
movl $0x110, %edx            # imm = 0x110
leaq 0x2755(%rip), %rcx      # 0x98d4
callq 0x2130
callq 0x6b70
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: sx126x_read_register
static int sx126x_read_register( const void* context, const uint16_t address, uint8_t* buffer, const uint8_t size ) {
    uint8_t buf[SX126X_SIZE_READ_REGISTER] = { 0 };
    int status = -1;
    buf[0] = RADIO_READ_REGISTER;
    buf[1] = ( uint8_t )( address >> 8 );
    buf[2] = ( uint8_t )( address >> 0 );
    buf[3] = 0;
    status = sx126x_hal_read( context, buf, SX126X_SIZE_READ_REGISTER, buffer, size, NULL );
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
leaq -0x1d(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x2100
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movb $0x1d, -0x1d(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x8, %eax
movb %al, -0x1c(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x0, %eax
movb %al, -0x1b(%rbp)
movb $0x0, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
movq -0x18(%rbp), %rcx
movzbl -0x19(%rbp), %eax
movl $0x4, %edx
xorl %r8d, %r8d
movl %r8d, %r9d
movzwl %ax, %r8d
callq 0x6e90
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: SX126xWriteBuffer
void SX126xWriteBuffer( uint8_t offset, uint8_t *buffer, uint8_t size )
{
    SX126xCheckDeviceReady( );
    int rc = sx126x_write_buffer(NULL, offset, buffer, size);
    assert(rc == 0);
    SX126xWaitOnBusy( );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
callq 0x5540
movb -0x1(%rbp), %al
movq -0x10(%rbp), %rdx
xorl %ecx, %ecx
movl %ecx, %edi
movzbl %al, %esi
movzbl -0x11(%rbp), %ecx
callq 0x72b0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x727e
jmp 0x729d
leaq 0x24a6(%rip), %rdi      # 0x972b
leaq 0x24a7(%rip), %rsi      # 0x9733
movl $0x11f, %edx            # imm = 0x11F
leaq 0x2674(%rip), %rcx      # 0x990c
callq 0x2130
callq 0x6b70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: sx126x_write_buffer
static int sx126x_write_buffer( const void* context, const uint8_t offset, const uint8_t* buffer,
    const uint8_t size ) {
    uint8_t buf[SX126X_SIZE_WRITE_BUFFER] = { 0 };
    buf[0] = RADIO_WRITE_BUFFER;
    buf[1] = offset;
    return sx126x_hal_write( context, buf, SX126X_SIZE_WRITE_BUFFER, buffer, size );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
leaq -0x1b(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2100
movb $0xe, -0x1b(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1b(%rbp), %rsi
movq -0x18(%rbp), %rcx
movzbl -0x19(%rbp), %eax
movl $0x2, %edx
movzwl %ax, %r8d
callq 0x6c20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: SX126xReadBuffer
void SX126xReadBuffer( uint8_t offset, uint8_t *buffer, uint8_t size )
{
    SX126xCheckDeviceReady( );
    int rc = sx126x_read_buffer(NULL, offset, buffer, size);
    assert(rc == 0);
    SX126xWaitOnBusy( );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
callq 0x5540
movb -0x1(%rbp), %al
movq -0x10(%rbp), %rdx
xorl %ecx, %ecx
movl %ecx, %edi
movzbl %al, %esi
movzbl -0x11(%rbp), %ecx
callq 0x7380
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x734e
jmp 0x736d
leaq 0x23d6(%rip), %rdi      # 0x972b
leaq 0x23d7(%rip), %rsi      # 0x9733
movl $0x127, %edx            # imm = 0x127
leaq 0x25d8(%rip), %rcx      # 0x9940
callq 0x2130
callq 0x6b70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: sx126x_read_buffer
static int sx126x_read_buffer( const void* context, const uint8_t offset, uint8_t* buffer, const uint8_t size ) {
    uint8_t buf[SX126X_SIZE_READ_BUFFER] = { 0 };
    int status = -1;
    buf[0] = RADIO_READ_BUFFER;
    buf[1] = offset;
    buf[2] = 0;
    status = sx126x_hal_read( context, buf, SX126X_SIZE_READ_BUFFER, buffer, size, NULL );
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x2100
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movb $0x1e, -0x1c(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x1b(%rbp)
movb $0x0, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movq -0x18(%rbp), %rcx
movzbl -0x19(%rbp), %eax
movl $0x3, %edx
xorl %r8d, %r8d
movl %r8d, %r9d
movzwl %ax, %r8d
callq 0x6e90
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: TimerInit
void TimerInit(
    struct ble_npl_callout *timer,  //  The timer to initialize. Cannot be NULL.
    ble_npl_event_fn *f)            //  The timer callback function. Cannot be NULL.
{
    puts("TimerInit");
    assert(timer != NULL);
    assert(f != NULL);

    //  Event Queue containing Events to be processed, defined in demo.c.  TODO: Move to header file.
    extern struct ble_npl_eventq event_queue;

    //  Init the Callout Timer with the Callback Function
    ble_npl_callout_init(
        timer,         //  Callout Timer
        &event_queue,  //  Event Queue that will handle the Callout upon timeout
        f,             //  Callback Function
        NULL           //  Argument to be passed to Callback Function
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x2519(%rip), %rdi      # 0x99c0
callq 0x22a0
cmpq $0x0, -0x8(%rbp)
je 0x74b5
jmp 0x74d4
leaq 0x250e(%rip), %rdi      # 0x99ca
leaq 0x2270(%rip), %rsi      # 0x9733
movl $0x16f, %edx            # imm = 0x16F
leaq 0x2509(%rip), %rcx      # 0x99d8
callq 0x2130
cmpq $0x0, -0x10(%rbp)
je 0x74dd
jmp 0x74fc
leaq 0x2531(%rip), %rdi      # 0x9a15
leaq 0x2248(%rip), %rsi      # 0x9733
movl $0x170, %edx            # imm = 0x170
leaq 0x24e1(%rip), %rcx      # 0x99d8
callq 0x2130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x6ce5(%rip), %rsi      # 0xe1f0
xorl %eax, %eax
movl %eax, %ecx
callq 0x78a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)