LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/createdfd.c
// Function: setChannelFlags
static uint32_t setChannelFlags(uint32_t channel, enum VkSuffix suffix)
{
    switch (suffix) {
    case s_UNORM: break;
    case s_SNORM:
        channel |=
            KHR_DF_SAMPLE_DATATYPE_SIGNED;
        break;
    case s_USCALED: break;
    case s_SSCALED:
        channel |=
            KHR_DF_SAMPLE_DATATYPE_SIGNED;
        break;
    case s_UINT: break;
    case s_SINT:
        channel |=
            KHR_DF_SAMPLE_DATATYPE_SIGNED;
        break;
    case s_SFLOAT:
        channel |=
            KHR_DF_SAMPLE_DATATYPE_FLOAT |
            KHR_DF_SAMPLE_DATATYPE_SIGNED;
        break;
    case s_UFLOAT:
        channel |=
            KHR_DF_SAMPLE_DATATYPE_FLOAT;
        break;
    case s_SRGB:
        if (channel == KHR_DF_CHANNEL_RGBSDA_ALPHA) {
            channel |= KHR_DF_SAMPLE_DATATYPE_LINEAR;
        }
        break;
    }
    return channel;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movq %rax, -0x10(%rsp)
subq $0x8, %rax
ja 0x36bb
movq -0x10(%rsp), %rax
leaq 0x3a81(%rip), %rcx      # 0x70d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x36bb
movl -0x4(%rsp), %eax
orl $0x40, %eax
movl %eax, -0x4(%rsp)
jmp 0x36bb
jmp 0x36bb
movl -0x4(%rsp), %eax
orl $0x40, %eax
movl %eax, -0x4(%rsp)
jmp 0x36bb
jmp 0x36bb
movl -0x4(%rsp), %eax
orl $0x40, %eax
movl %eax, -0x4(%rsp)
jmp 0x36bb
movl -0x4(%rsp), %eax
orl $0xc0, %eax
movl %eax, -0x4(%rsp)
jmp 0x36bb
movl -0x4(%rsp), %eax
orl $0x80, %eax
movl %eax, -0x4(%rsp)
jmp 0x36bb
cmpl $0xf, -0x4(%rsp)
jne 0x36b9
movl -0x4(%rsp), %eax
orl $0x10, %eax
movl %eax, -0x4(%rsp)
jmp 0x36bb
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/createdfd.c
// Function: createDFDDepthStencil
uint32_t *createDFDDepthStencil(int depthBits,
                                int stencilBits,
                                int sizeBytes)
{
    /* N.B. Little-endian is assumed. */
    uint32_t *DFD = 0;
    DFD = writeHeader((depthBits > 0) + (stencilBits > 0),
                      sizeBytes, s_UNORM, i_NON_COLOR);
    if (depthBits == 32) {
        writeSample(DFD, 0, KHR_DF_CHANNEL_RGBSDA_DEPTH,
                    32, 0,
                    1, 1, s_SFLOAT);
    } else if (depthBits > 0) {
        writeSample(DFD, 0, KHR_DF_CHANNEL_RGBSDA_DEPTH,
                    depthBits, 0,
                    1, 1, s_UNORM);
    }
    if (stencilBits > 0) {
        if (depthBits > 0) {
            writeSample(DFD, 1, KHR_DF_CHANNEL_RGBSDA_STENCIL,
                        stencilBits, depthBits,
                        1, 1, s_UINT);
        } else {
            writeSample(DFD, 0, KHR_DF_CHANNEL_RGBSDA_STENCIL,
                        stencilBits, 0,
                        1, 1, s_UINT);
        }
    }
    return DFD;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
setg %al
andb $0x1, %al
movzbl %al, %edi
cmpl $0x0, 0x20(%rsp)
setg %al
andb $0x1, %al
movzbl %al, %eax
addl %eax, %edi
movl 0x1c(%rsp), %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x21d0
movq %rax, 0x10(%rsp)
cmpl $0x20, 0x24(%rsp)
jne 0x3742
movq 0x10(%rsp), %rdi
xorl %r8d, %r8d
movl $0xe, %edx
movl $0x20, %ecx
movl $0x1, %r9d
movl %r8d, %esi
movl $0x1, (%rsp)
movl $0x6, 0x8(%rsp)
callq 0x22e0
jmp 0x3779
cmpl $0x0, 0x24(%rsp)
jle 0x3777
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %ecx
xorl %r8d, %r8d
movl $0xe, %edx
movl $0x1, %r9d
movl %r8d, %esi
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x22e0
jmp 0x3779
cmpl $0x0, 0x20(%rsp)
jle 0x37e9
cmpl $0x0, 0x24(%rsp)
jle 0x37b9
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %ecx
movl 0x24(%rsp), %r8d
movl $0x1, %r9d
movl $0xd, %edx
movl %r9d, %esi
movl $0x1, (%rsp)
movl $0x4, 0x8(%rsp)
callq 0x22e0
jmp 0x37e7
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %ecx
xorl %r8d, %r8d
movl $0xd, %edx
movl $0x1, %r9d
movl %r8d, %esi
movl $0x1, (%rsp)
movl $0x4, 0x8(%rsp)
callq 0x22e0
jmp 0x37e9
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/createdfd.c
// Function: createDFDAlpha
uint32_t *createDFDAlpha(int bigEndian, int bytes,
                         enum VkSuffix suffix) {
    uint32_t *DFD;
    int channel = 3; /* alpha channel */
    if (bigEndian) {
        int channelByte;
        /* Number of samples = number of channels * bytes per channel */
        DFD = writeHeader(bytes, bytes, suffix, i_COLOR);
        /* Loop over the bytes that constitute a channel */
        for (channelByte = 0; channelByte < bytes; ++channelByte) {
            writeSample(DFD, channelByte, channel,
                        8, 8 * (bytes - channelByte - 1),
                        channelByte == bytes-1, channelByte == 0, suffix);
        }
    } else { /* Little-endian */
        /* One sample per channel */
        DFD = writeHeader(1, bytes, suffix, i_COLOR);
        writeSample(DFD, 0, channel,
                    8 * bytes, 0,
                    1, 1, suffix);
    }
    return DFD;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl $0x3, 0x1c(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x38b5
movl 0x30(%rsp), %edi
movl 0x30(%rsp), %esi
movl 0x2c(%rsp), %edx
xorl %ecx, %ecx
callq 0x21d0
movq %rax, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x38b3
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
movl 0x1c(%rsp), %edx
movl 0x30(%rsp), %r8d
subl 0x18(%rsp), %r8d
subl $0x1, %r8d
shll $0x3, %r8d
movl 0x18(%rsp), %eax
movl 0x30(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %r9d
cmpl $0x0, 0x18(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %r10d
movl 0x2c(%rsp), %eax
movl $0x8, %ecx
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x22e0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3843
jmp 0x38fe
movl 0x30(%rsp), %esi
movl 0x2c(%rsp), %edx
movl $0x1, %edi
xorl %ecx, %ecx
callq 0x21d0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0x30(%rsp), %ecx
shll $0x3, %ecx
movl 0x2c(%rsp), %eax
xorl %r8d, %r8d
movl $0x1, %r9d
movl %r8d, %esi
movl $0x1, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x22e0
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/printdfd.c
// Function: dfdToStringVendorID
const char* dfdToStringVendorID(khr_df_vendorid_e value) {
    switch (value) {
    case KHR_DF_VENDORID_KHRONOS:
        return "KHR_DF_VENDORID_KHRONOS";

    case KHR_DF_VENDORID_MAX:
        // These enum values are not meant for string representation. Ignore
        break;
    }
    return NULL;
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
testl %eax, %eax
je 0x3ccf
jmp 0x3cc2
movl -0x10(%rsp), %eax
subl $0x1ffff, %eax          # imm = 0x1FFFF
je 0x3cdd
jmp 0x3cdf
leaq 0x40fe(%rip), %rax      # 0x7dd4
movq %rax, -0x8(%rsp)
jmp 0x3ce8
jmp 0x3cdf
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/printdfd.c
// Function: dfdToStringDescriptorType
const char* dfdToStringDescriptorType(khr_df_khr_descriptortype_e value) {
    switch (value) {
    case KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT:
        return "KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT";
    case KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_PLANES:
        return "KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_PLANES";
    case KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_DIMENSIONS:
        return "KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_DIMENSIONS";

    case KHR_DF_KHR_DESCRIPTORTYPE_NEEDED_FOR_WRITE_BIT:
    case KHR_DF_KHR_DESCRIPTORTYPE_NEEDED_FOR_DECODE_BIT:
    case KHR_DF_KHR_DESCRIPTORTYPE_MAX:
        // These enum values are not meant for string representation. Ignore
        break;
    }
    return NULL;
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
testl %eax, %eax
je 0x3d43
jmp 0x3d02
movl -0x10(%rsp), %eax
subl $0x2000, %eax           # imm = 0x2000
je 0x3d6d
jmp 0x3d0f
movl -0x10(%rsp), %eax
subl $0x4000, %eax           # imm = 0x4000
je 0x3d6d
jmp 0x3d1c
movl -0x10(%rsp), %eax
subl $0x6001, %eax           # imm = 0x6001
je 0x3d51
jmp 0x3d29
movl -0x10(%rsp), %eax
subl $0x6002, %eax           # imm = 0x6002
je 0x3d5f
jmp 0x3d36
movl -0x10(%rsp), %eax
subl $0x7fff, %eax           # imm = 0x7FFF
je 0x3d6d
jmp 0x3d6f
leaq 0x40a2(%rip), %rax      # 0x7dec
movq %rax, -0x8(%rsp)
jmp 0x3d78
leaq 0x40ba(%rip), %rax      # 0x7e12
movq %rax, -0x8(%rsp)
jmp 0x3d78
leaq 0x40d8(%rip), %rax      # 0x7e3e
movq %rax, -0x8(%rsp)
jmp 0x3d78
jmp 0x3d6f
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/printdfd.c
// Function: dfdToStringVersionNumber
const char* dfdToStringVersionNumber(khr_df_versionnumber_e value) {
    switch (value) {
    case KHR_DF_VERSIONNUMBER_1_1:
    // case KHR_DF_VERSIONNUMBER_1_0: // Fallthrough, Matching values
        return "KHR_DF_VERSIONNUMBER_1_1";
    case KHR_DF_VERSIONNUMBER_1_2:
        return "KHR_DF_VERSIONNUMBER_1_2";
    case KHR_DF_VERSIONNUMBER_1_3:
        return "KHR_DF_VERSIONNUMBER_1_3";

    // case KHR_DF_VERSIONNUMBER_LATEST: // Fallthrough, Matching values
    case KHR_DF_VERSIONNUMBER_MAX:
        // These enum values are not meant for string representation. Ignore
        break;
    }
    return NULL;
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
testl %eax, %eax
je 0x3db5
jmp 0x3d92
movl -0x10(%rsp), %eax
subl $0x1, %eax
je 0x3dc3
jmp 0x3d9d
movl -0x10(%rsp), %eax
subl $0x2, %eax
je 0x3dd1
jmp 0x3da8
movl -0x10(%rsp), %eax
subl $0xffff, %eax           # imm = 0xFFFF
je 0x3ddf
jmp 0x3de1
leaq 0x40b2(%rip), %rax      # 0x7e6e
movq %rax, -0x8(%rsp)
jmp 0x3dea
leaq 0x40bd(%rip), %rax      # 0x7e87
movq %rax, -0x8(%rsp)
jmp 0x3dea
leaq 0x40c8(%rip), %rax      # 0x7ea0
movq %rax, -0x8(%rsp)
jmp 0x3dea
jmp 0x3de1
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/printdfd.c
// Function: dfdToStringFlagsBit
const char* dfdToStringFlagsBit(uint32_t bit_index, bool bit_value) {
    switch (bit_index) {
    case 0:
        return bit_value ? "KHR_DF_FLAG_ALPHA_PREMULTIPLIED" : "KHR_DF_FLAG_ALPHA_STRAIGHT";
    default:
        return NULL;
    }
}

// Assembly:
movb %sil, %al
movl %edi, -0xc(%rsp)
andb $0x1, %al
movb %al, -0xd(%rsp)
movl -0xc(%rsp), %eax
testl %eax, %eax
jne 0x3e27
jmp 0x3e07
movb -0xd(%rsp), %dl
leaq 0x40c7(%rip), %rax      # 0x7ed9
leaq 0x40a0(%rip), %rcx      # 0x7eb9
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x3e30
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/printdfd.c
// Function: dfdToStringColorPrimaries
const char* dfdToStringColorPrimaries(khr_df_primaries_e value) {
    switch (value) {
    case KHR_DF_PRIMARIES_UNSPECIFIED:
        return "KHR_DF_PRIMARIES_UNSPECIFIED";
    case KHR_DF_PRIMARIES_BT709:
    // case KHR_DF_PRIMARIES_SRGB: // Fallthrough, Matching values
        return "KHR_DF_PRIMARIES_BT709";
    case KHR_DF_PRIMARIES_BT601_EBU:
        return "KHR_DF_PRIMARIES_BT601_EBU";
    case KHR_DF_PRIMARIES_BT601_SMPTE:
        return "KHR_DF_PRIMARIES_BT601_SMPTE";
    case KHR_DF_PRIMARIES_BT2020:
        return "KHR_DF_PRIMARIES_BT2020";
    case KHR_DF_PRIMARIES_CIEXYZ:
        return "KHR_DF_PRIMARIES_CIEXYZ";
    case KHR_DF_PRIMARIES_ACES:
        return "KHR_DF_PRIMARIES_ACES";
    case KHR_DF_PRIMARIES_ACESCC:
        return "KHR_DF_PRIMARIES_ACESCC";
    case KHR_DF_PRIMARIES_NTSC1953:
        return "KHR_DF_PRIMARIES_NTSC1953";
    case KHR_DF_PRIMARIES_PAL525:
        return "KHR_DF_PRIMARIES_PAL525";
    case KHR_DF_PRIMARIES_DISPLAYP3:
        return "KHR_DF_PRIMARIES_DISPLAYP3";
    case KHR_DF_PRIMARIES_ADOBERGB:
        return "KHR_DF_PRIMARIES_ADOBERGB";

    case KHR_DF_PRIMARIES_MAX:
        // These enum values are not meant for string representation. Ignore
        break;
    }
    return NULL;
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
testl %eax, %eax
je 0x418f
jmp 0x40d6
movl -0x10(%rsp), %eax
subl $0x1, %eax
je 0x41a0
jmp 0x40e5
movl -0x10(%rsp), %eax
subl $0x2, %eax
je 0x41b1
jmp 0x40f4
movl -0x10(%rsp), %eax
subl $0x3, %eax
je 0x41c2
jmp 0x4103
movl -0x10(%rsp), %eax
subl $0x4, %eax
je 0x41d0
jmp 0x4112
movl -0x10(%rsp), %eax
subl $0x5, %eax
je 0x41de
jmp 0x4121
movl -0x10(%rsp), %eax
subl $0x6, %eax
je 0x41ec
jmp 0x4130
movl -0x10(%rsp), %eax
subl $0x7, %eax
je 0x41fa
jmp 0x413f
movl -0x10(%rsp), %eax
subl $0x8, %eax
je 0x4208
jmp 0x414e
movl -0x10(%rsp), %eax
subl $0x9, %eax
je 0x4216
jmp 0x415d
movl -0x10(%rsp), %eax
subl $0xa, %eax
je 0x4224
jmp 0x416c
movl -0x10(%rsp), %eax
subl $0xb, %eax
je 0x4232
jmp 0x417b
movl -0x10(%rsp), %eax
subl $0xff, %eax
je 0x4240
jmp 0x4242
leaq 0x3f1c(%rip), %rax      # 0x80b2
movq %rax, -0x8(%rsp)
jmp 0x424b
leaq 0x3f28(%rip), %rax      # 0x80cf
movq %rax, -0x8(%rsp)
jmp 0x424b
leaq 0x3f2e(%rip), %rax      # 0x80e6
movq %rax, -0x8(%rsp)
jmp 0x424b
leaq 0x3f38(%rip), %rax      # 0x8101
movq %rax, -0x8(%rsp)
jmp 0x424b
leaq 0x3f47(%rip), %rax      # 0x811e
movq %rax, -0x8(%rsp)
jmp 0x424b
leaq 0x3f51(%rip), %rax      # 0x8136
movq %rax, -0x8(%rsp)
jmp 0x424b
leaq 0x3f5b(%rip), %rax      # 0x814e
movq %rax, -0x8(%rsp)
jmp 0x424b
leaq 0x3f63(%rip), %rax      # 0x8164
movq %rax, -0x8(%rsp)
jmp 0x424b
leaq 0x3f6d(%rip), %rax      # 0x817c
movq %rax, -0x8(%rsp)
jmp 0x424b
leaq 0x3f79(%rip), %rax      # 0x8196
movq %rax, -0x8(%rsp)
jmp 0x424b
leaq 0x3f83(%rip), %rax      # 0x81ae
movq %rax, -0x8(%rsp)
jmp 0x424b
leaq 0x3f90(%rip), %rax      # 0x81c9
movq %rax, -0x8(%rsp)
jmp 0x424b
jmp 0x4242
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/printdfd.c
// Function: dfdToStringSampleDatatypeQualifiers
const char* dfdToStringSampleDatatypeQualifiers(uint32_t bit_index, bool bit_value) {
    if (!bit_value)
        return NULL;

    switch (1u << bit_index) {
    case KHR_DF_SAMPLE_DATATYPE_LINEAR:
        return "KHR_DF_SAMPLE_DATATYPE_LINEAR";
    case KHR_DF_SAMPLE_DATATYPE_EXPONENT:
        return "KHR_DF_SAMPLE_DATATYPE_EXPONENT";
    case KHR_DF_SAMPLE_DATATYPE_SIGNED:
        return "KHR_DF_SAMPLE_DATATYPE_SIGNED";
    case KHR_DF_SAMPLE_DATATYPE_FLOAT:
        return "KHR_DF_SAMPLE_DATATYPE_FLOAT";
    }
    return NULL;
}

// Assembly:
movb %sil, %al
movl %edi, -0xc(%rsp)
andb $0x1, %al
movb %al, -0xd(%rsp)
testb $0x1, -0xd(%rsp)
jne 0x44af
movq $0x0, -0x8(%rsp)
jmp 0x4529
movb -0xc(%rsp), %cl
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rsp)
subl $0x10, %eax
je 0x44e8
jmp 0x44c5
movl -0x14(%rsp), %eax
subl $0x20, %eax
je 0x44f6
jmp 0x44d0
movl -0x14(%rsp), %eax
subl $0x40, %eax
je 0x4504
jmp 0x44db
movl -0x14(%rsp), %eax
subl $0x80, %eax
je 0x4512
jmp 0x4520
leaq 0x3f3b(%rip), %rax      # 0x842a
movq %rax, -0x8(%rsp)
jmp 0x4529
leaq 0x3f4b(%rip), %rax      # 0x8448
movq %rax, -0x8(%rsp)
jmp 0x4529
leaq 0x3f5d(%rip), %rax      # 0x8468
movq %rax, -0x8(%rsp)
jmp 0x4529
leaq 0x3f6d(%rip), %rax      # 0x8486
movq %rax, -0x8(%rsp)
jmp 0x4529
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/printdfd.c
// Function: printFlagBits
static void printFlagBits(uint32_t flags, const char*(*toStringFn)(uint32_t, bool)) {
    bool first = true;
    for (uint32_t bit_index = 0; bit_index < 32; ++bit_index) {
        uint32_t bit_mask = 1u << bit_index;
        bool bit_value = (bit_mask & (uint32_t) flags) != 0;

        const char* comma = first ? "" : ", ";
        const char* str = toStringFn(bit_index, bit_value);
        if (str) {
            printf("%s%s", comma, str);
            first = false;
        } else if (bit_value) {
            printf("%s%u", comma, bit_mask);
            first = false;
        }
    }
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movb $0x1, 0x27(%rsp)
movl $0x0, 0x20(%rsp)
cmpl $0x20, 0x20(%rsp)
jae 0x5aae
movl 0x20(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
andl 0x34(%rsp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x1b(%rsp)
movb 0x27(%rsp), %dl
leaq 0x39b6(%rip), %rax      # 0x93d9
leaq 0x3688(%rip), %rcx      # 0x90b2
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl 0x20(%rsp), %edi
movb 0x1b(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %esi
callq *%rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5a77
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x3973(%rip), %rdi      # 0x93dc
movb $0x0, %al
callq 0x1030
movb $0x0, 0x27(%rsp)
jmp 0x5a9c
testb $0x1, 0x1b(%rsp)
je 0x5a9a
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edx
leaq 0x3736(%rip), %rdi      # 0x91c4
movb $0x0, %al
callq 0x1030
movb $0x0, 0x27(%rsp)
jmp 0x5a9c
jmp 0x5a9e
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x59ea
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/printdfd.c
// Function: printFlagBitsJSON
static void printFlagBitsJSON(uint32_t indent, const char* nl, uint32_t flags, const char*(*toStringFn)(uint32_t, bool)) {
    bool first = true;
    for (uint32_t bit_index = 0; bit_index < 32; ++bit_index) {
        uint32_t bit_mask = 1u << bit_index;
        bool bit_value = (bit_mask & (uint32_t) flags) != 0;

        const char* str = toStringFn(bit_index, bit_value);
        if (str) {
            printf("%s%s%*s\"%s\"", first ? "" : ",", first ? "" : nl, indent, "", str);
            first = false;
        } else if (bit_value) {
            printf("%s%s%*s%u", first ? "" : ",", first ? "" : nl, indent, "", bit_mask);
            first = false;
        }
    }
    if (!first)
        printf("%s", nl);
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movb $0x1, 0x37(%rsp)
movl $0x0, 0x30(%rsp)
cmpl $0x20, 0x30(%rsp)
jae 0x6f21
movl 0x30(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
andl 0x44(%rsp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x2b(%rsp)
movq 0x38(%rsp), %rax
movl 0x30(%rsp), %edi
movb 0x2b(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %esi
callq *%rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x6e9f
movb 0x37(%rsp), %dl
leaq 0x25af(%rip), %rax      # 0x93ed
leaq 0x226d(%rip), %rcx      # 0x90b2
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x37(%rsp)
je 0x6e66
leaq 0x2253(%rip), %rax      # 0x90b2
movq %rax, 0x10(%rsp)
jmp 0x6e70
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0x54(%rsp), %ecx
movq 0x20(%rsp), %r9
leaq 0x2557(%rip), %rdi      # 0x93e1
leaq 0x2221(%rip), %r8       # 0x90b2
movb $0x0, %al
callq 0x1030
movb $0x0, 0x37(%rsp)
jmp 0x6f0f
testb $0x1, 0x2b(%rsp)
je 0x6f0d
movb 0x37(%rsp), %dl
leaq 0x253c(%rip), %rax      # 0x93ed
leaq 0x21fa(%rip), %rcx      # 0x90b2
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x37(%rsp)
je 0x6ed8
leaq 0x21e0(%rip), %rax      # 0x90b2
movq %rax, (%rsp)
jmp 0x6ee1
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movl 0x54(%rsp), %ecx
movl 0x2c(%rsp), %r9d
leaq 0x24f5(%rip), %rdi      # 0x93ef
leaq 0x21b1(%rip), %r8       # 0x90b2
movb $0x0, %al
callq 0x1030
movb $0x0, 0x37(%rsp)
jmp 0x6f0f
jmp 0x6f11
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x6de3
testb $0x1, 0x37(%rsp)
jne 0x6f3b
movq 0x48(%rsp), %rsi
leaq 0x23c0(%rip), %rdi      # 0x92f4
movb $0x0, %al
callq 0x1030
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Pal/main.c
// Function: main
int main(int argc, char *argv[])
{
	char *filename = NULL;
	FILE *fin = NULL;
	int width, heigth;
	int square_width = 32, square_height = 32;
	unsigned char *pal = NULL;

	if (argc != 2)
	{
		fprintf(stderr, "%s <*.PAL>\n", argv[0]);
		return EXIT_FAILURE;
	}
	filename = argv[1];
	if (!(fin = fopen(filename, "rb")))
	{
		perror("fopen()");
		return EXIT_FAILURE;
	}
	if (!(pal = init_palette(fin)))
	{
		fclose(fin);
		return EXIT_FAILURE;
	}
	width = square_width * 16;
	heigth = square_height * 16;
	pal = expand_palette(pal, square_width, square_height);
	if (pal)
	{
		writeImage("./extract/test.png", width, heigth, pal, "pal");
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x20, -0x2c(%rbp)
movl $0x20, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x163d
movq 0x29df(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xa4e(%rip), %rsi       # 0x2078
movb $0x0, %al
callq 0x10c0
movl $0x1, -0x4(%rbp)
jmp 0x16ed
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xa30(%rip), %rsi       # 0x2084
callq 0x1140
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1678
leaq 0x99d(%rip), %rdi       # 0x2007
callq 0x1150
movl $0x1, -0x4(%rbp)
jmp 0x16ed
movq -0x20(%rbp), %rdi
callq 0x1780
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x169d
movq -0x20(%rbp), %rdi
callq 0x1070
movl $0x1, -0x4(%rbp)
jmp 0x16ed
movl -0x2c(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x24(%rbp)
movl -0x30(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x1880
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x16e6
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq -0x38(%rbp), %rcx
leaq 0x9ad(%rip), %rdi       # 0x2087
leaq 0x9b9(%rip), %r8        # 0x209a
callq 0x12c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Pal/pal.c
// Function: open_palette
unsigned char *open_palette(char *filename)
{
	FILE *fin = NULL;
	unsigned char *pal = NULL;

	if (!(fin = fopen(filename, "rb")))
	{
		perror("fopen()");
		return NULL;
	}
	pal = init_palette(fin);
	fclose(fin);
	return pal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x95d(%rip), %rsi       # 0x2084
callq 0x1140
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x174c
leaq 0x8ca(%rip), %rdi       # 0x2007
callq 0x1150
movq $0x0, -0x8(%rbp)
jmp 0x176a
movq -0x18(%rbp), %rdi
callq 0x1780
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1070
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Pal/pal.c
// Function: init_palette
unsigned char *init_palette(FILE *fin)
{
	unsigned char *pal = NULL;
	unsigned int filesize;

	if (!(pal = malloc(sizeof (struct color) * 256)))
	{
		perror("malloc()");
		return NULL;
	}
        fseek(fin, 0, SEEK_END);
        filesize = ftell(fin);
        fseek(fin, 0, SEEK_SET);
	if (filesize != (256 * 3))
	{
		fprintf(stderr, "[-] Palette not handled\n");
		free(pal);
		return NULL;
	}
	if (fread(pal, 1, filesize, fin) != filesize)
	{
		perror("fread()");
		free(pal);
		return NULL;
	}
	return pal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x300, %edi            # imm = 0x300
callq 0x1110
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x17c1
leaq 0x8ef(%rip), %rdi       # 0x209e
callq 0x1150
movq $0x0, -0x8(%rbp)
jmp 0x1868
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1120
movq -0x10(%rbp), %rdi
callq 0x10d0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1120
cmpl $0x300, -0x1c(%rbp)     # imm = 0x300
je 0x1822
movq 0x27fa(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x89f(%rip), %rsi       # 0x20a7
movb $0x0, %al
callq 0x10c0
movq -0x18(%rbp), %rdi
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0x1868
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x1050
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
je 0x1860
leaq 0x878(%rip), %rdi       # 0x20c0
callq 0x1150
movq -0x18(%rbp), %rdi
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0x1868
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Pal/pal.c
// Function: expand_palette
unsigned char *expand_palette(unsigned char *pal, unsigned square_width, unsigned square_height)
{
	unsigned char *newpal = NULL;
	unsigned char *spal = NULL;
	unsigned int i, j, k, l;

	if (!(newpal = malloc(sizeof (char) * 256 * 3 * square_width * square_height)))
	{
		perror("malloc()");
		return NULL;
	}
	spal = newpal;
	for (i = 0; i < 16; i++)
	{
		for (j = 0; j < square_height; j++)
		{
			for (k = 0; k < 16; k++)
			{
				struct color *rgb;
				rgb = (struct color*)&pal[(k + (i * 16)) * 3];
				for (l = 0; l < square_width; l++)
				{
					memcpy(newpal, rgb, sizeof (struct color));
					newpal += 3;
				}
			}
		}
	}
	return spal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x14(%rbp), %eax
imulq $0x300, %rax, %rdi      # imm = 0x300
movl -0x18(%rbp), %eax
imulq %rax, %rdi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x18db
leaq 0x7d5(%rip), %rdi       # 0x209e
callq 0x1150
movq $0x0, -0x8(%rbp)
jmp 0x199a
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x10, -0x2c(%rbp)
jae 0x1992
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x1982
movl $0x0, -0x34(%rbp)
cmpl $0x10, -0x34(%rbp)
jae 0x1972
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
movl -0x2c(%rbp), %edx
shll $0x4, %edx
addl %edx, %ecx
imull $0x3, %ecx, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1965
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movw (%rcx), %dx
movw %dx, (%rax)
movb 0x2(%rcx), %cl
movb %cl, 0x2(%rax)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1932
jmp 0x1967
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x190a
jmp 0x1974
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x18fb
jmp 0x1984
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x18ea
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/s3/dns.c
// Function: dnsrun
static void
dnsrun(const char * target, int s)
{
	struct sock_addr ** sas;
	uint8_t * addr;
	size_t addrlen;
	size_t i;

	/*
	 * Infinite loop doing DNS lookups and writing them to our parent via
	 * the socket, sleeping 10 seconds between each lookup.
	 */
	for (;; sleep(10)) {
		/* Perform a DNS lookup. */
		if ((sas = sock_resolve(target)) == NULL)
			continue;

		/* Send each address over. */
		for (i = 0; sas[i] != NULL; i++) {
			/* Serialize the address. */
			if (sock_addr_serialize(sas[i], &addr, &addrlen))
				goto die;

			/* Send it to our parent. */
			if (noeintr_write(s, &addrlen, sizeof(addrlen)) == -1)
				goto die;
			if (noeintr_write(s, addr, addrlen) == -1)
				goto die;

			/* Free the serialized address. */
			free(addr);
		}

		/* Free the list of addresses. */
		sock_addr_freelist(sas);
	}

	/* NOTREACHED */

die:
	_exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xca00
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3c57
jmp 0x3cdf
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x3cd6
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xdfd0
cmpl $0x0, %eax
je 0x3c8e
jmp 0x3cee
movl -0xc(%rbp), %edi
leaq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0xc8e0
cmpq $-0x1, %rax
jne 0x3ca7
jmp 0x3cee
movl -0xc(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xc8e0
cmpq $-0x1, %rax
jne 0x3cbf
jmp 0x3cee
movq -0x20(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3c5f
movq -0x18(%rbp), %rdi
callq 0xd630
movl $0xa, %edi
callq 0x24d0
jmp 0x3c3f
movl $0x1, %edi
callq 0x20c0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/s3/dns.c
// Function: callback_read_len
static int
callback_read_len(void * cookie, ssize_t readlen)
{
	struct dns_reader * DR = cookie;

	/* If we failed to read a size_t, something is seriously wrong. */
	if (readlen != sizeof(size_t))
		goto err1;

	/* Sanity-check. */
	if (DR->addrlen > SSIZE_MAX)
		goto err1;

	/* Allocate space to hold the address. */
	if ((DR->addr = malloc(DR->addrlen)) == NULL)
		goto err0;

	/* Read the address. */
	if ((DR->read_cookie = network_read(DR->s, DR->addr, DR->addrlen,
	    DR->addrlen, callback_read_addr, DR)) == NULL)
		goto err1;

	/* Success! */
	return (0);

err1:
	warnp("Error reading address via socket");
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x8, -0x18(%rbp)
je 0x3d21
jmp 0x3d9f
movq -0x20(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x10(%rax)
jbe 0x3d37
jmp 0x3d9f
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2350
movq -0x20(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x3d57
jmp 0x3dd8
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %r9
leaq 0xbf(%rip), %r8         # 0x3e40
callq 0xa410
movq -0x20(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x3d96
jmp 0x3d9f
movl $0x0, -0x4(%rbp)
jmp 0x3ddf
jmp 0x3da1
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3dc6
leaq 0x1a76e(%rip), %rdi     # 0x1e520
movb $0x0, %al
callq 0xe670
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3dd4
leaq 0x1a753(%rip), %rdi     # 0x1e520
movb $0x0, %al
callq 0xe8c0
jmp 0x3dd6
jmp 0x3dd8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/s3/dns.c
// Function: dns_reader_stop
void
dns_reader_stop(struct dns_reader * DR)
{

	/* Signal the child process to die. */
	kill(DR->pid, SIGTERM);

	/* Stop reading addresses. */
	network_read_cancel(DR->read_cookie);

	/* Free the address buffer, if we have one. */
	free(DR->addr);

	/* Free the cookie. */
	free(DR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
movl $0xf, %esi
callq 0x2330
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xa6e0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/s3/dns.c
// Function: callback_read_addr
static int
callback_read_addr(void * cookie, ssize_t readlen)
{
	struct dns_reader * DR = cookie;
	struct sock_addr * sa;

	/* If we failed to read, something is seriously wrong. */
	if (readlen != (ssize_t)DR->addrlen)
		goto err1;

	/* Parse the address. */
	if ((sa = sock_addr_deserialize(DR->addr, DR->addrlen)) == NULL)
		goto err0;

	/* Free the serialized address. */
	free(DR->addr);
	DR->addr = NULL;

	/* Add the address to the S3 request queue. */
	if (s3_request_queue_addaddr(DR->Q, sa, 600)) {
		warnp("Error adding S3 endpoint address");
		sock_addr_free(sa);
		goto err0;
	}

	/* Free the parsed address. */
	sock_addr_free(sa);

	/* Start reading another address. */
	if ((DR->read_cookie = network_read(DR->s, (uint8_t *)&DR->addrlen,
	    sizeof(size_t), sizeof(size_t), callback_read_len, DR)) == NULL)
		goto err1;

	/* Success! */
	return (0);

err1:
	warnp("Error reading address via socket");
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x3e6b
jmp 0x3f50
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xe0a0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3e8f
jmp 0x3f89
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movl $0x258, %edx            # imm = 0x258
callq 0xfce0
cmpl $0x0, %eax
je 0x3f07
jmp 0x3ec4
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3ee9
leaq 0x1a373(%rip), %rdi     # 0x1e248
movb $0x0, %al
callq 0xe670
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3ef7
leaq 0x1a358(%rip), %rdi     # 0x1e248
movb $0x0, %al
callq 0xe8c0
jmp 0x3ef9
movq -0x28(%rbp), %rdi
callq 0xd5f0
jmp 0x3f89
movq -0x28(%rbp), %rdi
callq 0xd5f0
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
movq -0x20(%rbp), %r9
movl $0x8, %ecx
leaq -0x22f(%rip), %r8       # 0x3d00
movq %rcx, %rdx
callq 0xa410
movq -0x20(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x3f47
jmp 0x3f50
movl $0x0, -0x4(%rbp)
jmp 0x3f90
jmp 0x3f52
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3f77
leaq 0x1a5bd(%rip), %rdi     # 0x1e520
movb $0x0, %al
callq 0xe670
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3f85
leaq 0x1a5a2(%rip), %rdi     # 0x1e520
movb $0x0, %al
callq 0xe8c0
jmp 0x3f87
jmp 0x3f89
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/s3/dispatch.c
// Function: dispatch_accept
struct dispatch_state *
dispatch_accept(struct s3_request_queue * Q, int s)
{
	struct dispatch_state * D;

	/* Allocate space for dispatcher state. */
	if ((D = malloc(sizeof(struct dispatch_state))) == NULL)
		goto err0;

	/* Initialize dispatcher. */
	D->Q = Q;
	D->ip_head = D->ip_tail = NULL;

	/* Accept a connection. */
	D->accepting = 1;
	if (network_accept(s, callback_accept, D) == NULL)
		goto err1;

	/* Success! */
	return (D);

err1:
	free(D);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x38, %edi
callq 0x2350
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3fc5
jmp 0x4021
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x18(%rax)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rdx
leaq 0x3f(%rip), %rsi        # 0x4040
callq 0x9c30
cmpq $0x0, %rax
jne 0x400e
jmp 0x4018
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4029
movq -0x20(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/s3/dispatch.c
// Function: dispatch_done
int
dispatch_done(struct dispatch_state * D)
{

	/* Sanity check. */
	assert(D->accepting == 0);
	assert(D->read_cookie == NULL);
	assert(D->ip_head == NULL);
	assert(D->ip_tail == NULL);

	/* Free the buffered reader for the connection. */
	netbuf_read_free(D->readq);

	/* Free the buffered writer for the connection. */
	netbuf_write_free(D->writeq);

	/* Close the connection. */
	while (close(D->sconn)) {
		if (errno == EINTR)
			continue;
		warnp("close");
		goto err0;
	}

	/* Free allocated memory. */
	free(D);

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x42e8
jmp 0x4307
leaq 0x1a3dd(%rip), %rdi     # 0x1e6cc
leaq 0x1a3e8(%rip), %rsi     # 0x1e6de
movl $0x1bc, %edx            # imm = 0x1BC
leaq 0x1a3e7(%rip), %rcx     # 0x1e6e9
callq 0x2200
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x4314
jmp 0x4333
leaq 0x1a3f9(%rip), %rdi     # 0x1e714
leaq 0x1a3bc(%rip), %rsi     # 0x1e6de
movl $0x1bd, %edx            # imm = 0x1BD
leaq 0x1a3bb(%rip), %rcx     # 0x1e6e9
callq 0x2200
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4340
jmp 0x435f
leaq 0x1a3e4(%rip), %rdi     # 0x1e72b
leaq 0x1a390(%rip), %rsi     # 0x1e6de
movl $0x1be, %edx            # imm = 0x1BE
leaq 0x1a38f(%rip), %rcx     # 0x1e6e9
callq 0x2200
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x436c
jmp 0x438b
leaq 0x1a3cb(%rip), %rdi     # 0x1e73e
leaq 0x1a364(%rip), %rsi     # 0x1e6de
movl $0x1bf, %edx            # imm = 0x1BF
leaq 0x1a363(%rip), %rcx     # 0x1e6e9
callq 0x2200
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x9330
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x9a00
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x2220
cmpl $0x0, %eax
je 0x43fb
callq 0x20a0
cmpl $0x4, (%rax)
jne 0x43c2
jmp 0x43a5
jmp 0x43c4
callq 0x20a0
cmpl $0x0, (%rax)
je 0x43e9
leaq 0x1a6ee(%rip), %rdi     # 0x1eac3
movb $0x0, %al
callq 0xe670
callq 0x20a0
movl $0x0, (%rax)
jmp 0x43f7
leaq 0x1a6d3(%rip), %rdi     # 0x1eac3
movb $0x0, %al
callq 0xe8c0
jmp 0x43f9
jmp 0x440d
movq -0x10(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x4414
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/s3/dispatch.c
// Function: dropconnection
static int
dropconnection(void * cookie)
{
	struct dispatch_state * D = cookie;

	/* If we're waiting for a request to arrive, stop waiting. */
	if (D->read_cookie != NULL) {
		wire_readpacket_wait_cancel(D->read_cookie);
		D->read_cookie = NULL;
	}

	/*
	 * Flush the S3 request queue: If the connection is dying, we won't be
	 * able to send responses back, so there's no point processing the
	 * requests.
	 */
	s3_request_queue_flush(D->Q);

	/* Free the list of in-progress requests. */
	while (D->ip_head != NULL)
		request_dequeue(D, D->ip_head);

	/* Success!  (We can't fail -- but netbuf_write doesn't know that.) */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x4458
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x10ea0
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10020
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4482
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4880
jmp 0x4464
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/s3/dispatch.c
// Function: request_dequeue
static void
request_dequeue(struct dispatch_state * D, struct request * R)
{

	/* Sanity-check linked list. */
	assert(D == R->D);

	/* Free the contents of the kivaloo-S3 request structure. */
	proto_s3_request_free(&R->R);

	/* Free extra allocations in the S3 request structure. */
	free(R->path);
	free(R->range);

	/* Remove from the linked list. */
	if (D->ip_head == R) {
		assert(R->prev == NULL);
		D->ip_head = R->next;
	} else {
		assert(R->prev != NULL);
		R->prev->next = R->next;
	}
	if (D->ip_tail == R) {
		assert(R->next == NULL);
		D->ip_tail = R->prev;
	} else {
		assert(R->next != NULL);
		R->next->prev = R->prev;
	}

	/* Free the request structure. */
	free(R);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x489f
jmp 0x48be
leaq 0x19f51(%rip), %rdi     # 0x1e7f7
leaq 0x19e31(%rip), %rsi     # 0x1e6de
movl $0x3e, %edx
leaq 0x19f48(%rip), %rcx     # 0x1e801
callq 0x2200
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xf760
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x4937
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4906
jmp 0x4925
leaq 0x19f34(%rip), %rdi     # 0x1e841
leaq 0x19dca(%rip), %rsi     # 0x1e6de
movl $0x49, %edx
leaq 0x19ee1(%rip), %rcx     # 0x1e801
callq 0x2200
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4977
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4944
jmp 0x4963
leaq 0x19f06(%rip), %rdi     # 0x1e851
leaq 0x19d8c(%rip), %rsi     # 0x1e6de
movl $0x4c, %edx
leaq 0x19ea3(%rip), %rcx     # 0x1e801
callq 0x2200
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x49c3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4992
jmp 0x49b1
leaq 0x19ec8(%rip), %rdi     # 0x1e861
leaq 0x19d3e(%rip), %rsi     # 0x1e6de
movl $0x50, %edx
leaq 0x19e55(%rip), %rcx     # 0x1e801
callq 0x2200
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x4a03
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x49d0
jmp 0x49ef
leaq 0x19e9a(%rip), %rdi     # 0x1e871
leaq 0x19d00(%rip), %rsi     # 0x1e6de
movl $0x53, %edx
leaq 0x19e17(%rip), %rcx     # 0x1e801
callq 0x2200
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_server.c
// Function: proto_s3_request_read
int
proto_s3_request_read(struct netbuf_read * R, struct proto_s3_request * req)
{
	struct wire_packet P;

	/* Try to grab a packet from the buffered reader. */
	if (wire_readpacket_peek(R, &P))
		goto err0;

	/* Do we have a packet? */
	if (P.buf == NULL)
		goto nopacket;

	/* Parse this packet. */
	if (proto_s3_request_parse(&P, req))
		goto err0;

	/* Consume the packet. */
	wire_readpacket_consume(R, &P);

	/* Success! */
	return (0);

nopacket:
	/* Record that no request was available. */
	req->type = PROTO_S3_NONE;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10a30
cmpl $0x0, %eax
je 0xf494
jmp 0xf4db
cmpq $0x0, -0x20(%rbp)
jne 0xf49d
jmp 0xf4c7
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xf4f0
cmpl $0x0, %eax
je 0xf4b1
jmp 0xf4db
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10f00
movl $0x0, -0x4(%rbp)
jmp 0xf4e2
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl $0x0, -0x4(%rbp)
jmp 0xf4e2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_server.c
// Function: proto_s3_request_free
void
proto_s3_request_free(struct proto_s3_request * req)
{

	/* If this is a PUT, free the malloced data buffer. */
	if (req->type == PROTO_S3_PUT)
		free(req->r.put.buf);

	/* Free the object and bucket names. */
	free(req->object);
	free(req->bucket);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x10000, 0x8(%rax)     # imm = 0x10000
jne 0xf786
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_server.c
// Function: proto_s3_response_status
int
proto_s3_response_status(struct netbuf_write * Q, uint64_t ID, int status)
{
	uint8_t * wbuf;

	/* Sanity check. */
	assert((status == 0) || ((status >= 100) && (status <= 599)));

	/* Get a packet data buffer. */
	if ((wbuf = wire_writepacket_getbuf(Q, ID, 4)) == NULL)
		goto err0;

	/* Write the packet data. */
	be32enc(&wbuf[0], (uint32_t)status);

	/* Finish the packet. */
	if (wire_writepacket_done(Q, wbuf, 4))
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xf7d8
cmpl $0x64, -0x1c(%rbp)
jl 0xf7da
cmpl $0x257, -0x1c(%rbp)     # imm = 0x257
jg 0xf7da
jmp 0xf7f9
leaq 0x10797(%rip), %rdi     # 0x1ff78
leaq 0x107c6(%rip), %rsi     # 0x1ffae
movl $0xbe, %edx
leaq 0x107dc(%rip), %rcx     # 0x1ffd0
callq 0x2200
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x11220
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xf817
jmp 0xf845
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xf860
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x4, %edx
callq 0x11460
cmpl $0x0, %eax
je 0xf83c
jmp 0xf845
movl $0x0, -0x4(%rbp)
jmp 0xf84c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_server.c
// Function: proto_s3_response_data
int
proto_s3_response_data(struct netbuf_write * Q, uint64_t ID, int status,
    uint32_t len, const uint8_t * buf)
{
	uint8_t * wbuf;
	size_t rlen;

	/* Sanity check. */
	assert((status == 0) || ((status >= 100) && (status <= 599)));

	/* Compute the response length. */
	rlen = 8 + (((buf != NULL) && (len != (uint32_t)(-1))) ? len : 0);

	/* Get a packet data buffer. */
	if ((wbuf = wire_writepacket_getbuf(Q, ID, rlen)) == NULL)
		goto err0;

	/* Write the packet data. */
	be32enc(&wbuf[0], (uint32_t)status);
	be32enc(&wbuf[4], len);
	if ((buf != NULL) && (len != (uint32_t)(-1)))
		memcpy(&wbuf[8], buf, len);

	/* Finish the packet. */
	if (wire_writepacket_done(Q, wbuf, rlen))
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xf8ff
cmpl $0x64, -0x1c(%rbp)
jl 0xf901
cmpl $0x257, -0x1c(%rbp)     # imm = 0x257
jg 0xf901
jmp 0xf920
leaq 0x10670(%rip), %rdi     # 0x1ff78
leaq 0x1069f(%rip), %rsi     # 0x1ffae
movl $0xe3, %edx
leaq 0x106f8(%rip), %rcx     # 0x20013
callq 0x2200
cmpq $0x0, -0x28(%rbp)
je 0xf935
cmpl $-0x1, -0x20(%rbp)
je 0xf935
movl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0xf93c
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0xf93c
movl -0x3c(%rbp), %eax
addl $0x8, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x11220
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xf965
jmp 0xf9c5
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xf860
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
movl -0x20(%rbp), %esi
callq 0xf860
cmpq $0x0, -0x28(%rbp)
je 0xf9a4
cmpl $-0x1, -0x20(%rbp)
je 0xf9a4
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x2300
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x11460
cmpl $0x0, %eax
je 0xf9bc
jmp 0xf9c5
movl $0x0, -0x4(%rbp)
jmp 0xf9cc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)