LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/shuffle2[P]nx2elf/nx2elf.cpp
// Function: NsoFile::ResolvePlt(void*, unsigned long)
bool ResolvePlt(void* base, size_t len) {
    // Each plt slot is 4 instructions. The first entry fills 2 slots (resolving
    // thunk).
    if (dyn_info.pltrelsz) {
      const u32 plt_pattern[]{0xa9bf7bf0, 0xd00004d0, 0xf9428a11, 0x91144210,
                              0xd61f0220, 0xd503201f, 0xd503201f, 0xd503201f};
      const u32 plt_mask[ARRAY_SIZE(plt_pattern)]{
          0xffffffff, 0x00000000, 0xff000000, 0xff000000,
          0xff000000, 0xffffffff, 0xffffffff, 0xffffffff};
      auto found = static_cast<u8*>(
          memmem_m(base, len, plt_pattern, plt_mask, sizeof(plt_pattern)));
      if (found) {
        plt_info.addr = found - &image[0];
        // Assume the plt exactly matches .rela.plt
        u64 plt_entry_count = dyn_info.pltrelsz / sizeof(Elf64_Rela);
        const u64 plt_entry_size = sizeof(u32) * 4;
        plt_info.size = plt_entry_size * 2 + plt_entry_size * plt_entry_count;
        return true;
      }
    }
    return false;
  }

// Assembly:
movq 0x150(%rdi), %rax
testq %rax, %rax
je 0x8be8
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %rcx
addq $-0x20, %rcx
cmpq %rsi, %rcx
jb 0x8bb3
leaq 0xebae(%rip), %rdx      # 0x17730
leaq 0xeb87(%rip), %r8       # 0x17710
xorl %r9d, %r9d
movb (%r9,%r8), %r10b
xorb (%rsi,%r9), %r10b
andb (%r9,%rdx), %r10b
cmpq $0x1f, %r9
je 0x8ba6
incq %r9
testb %r10b, %r10b
je 0x8b8c
testb %r10b, %r10b
je 0x8bb5
incq %rsi
cmpq %rcx, %rsi
jbe 0x8b89
xorl %esi, %esi
testq %rsi, %rsi
je 0x8beb
subq 0x108(%rdi), %rsi
movq %rsi, 0x1b0(%rdi)
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
andq $-0x10, %rdx
addq $0x20, %rdx
movq %rdx, 0x1b8(%rdi)
movb $0x1, %al
jmp 0x8bed
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/shuffle2[P]nx2elf/nx2elf.cpp
// Function: StringTable::GetBuffer()
std::vector<char> GetBuffer() {
    std::vector<char> buffer(watermark);
    for (const auto& entry : entries) {
      strcpy(&buffer[entry.second], entry.first);
    }
    return buffer;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x38(%rsi), %esi
leaq -0x11(%rbp), %rdx
callq 0x9fe4
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x9fd7
movl 0x10(%r14), %edi
addq (%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x2180
movq (%r14), %r14
jmp 0x9fbd
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/shuffle2[P]nx2elf/lz4.c
// Function: LZ4_saveDict
int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
{
    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;

    DEBUGLOG(5, "LZ4_saveDict : dictSize=%i, safeBuffer=%p", dictSize, safeBuffer);

    if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */
    if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; }

    if (safeBuffer == NULL) assert(dictSize == 0);
    if (dictSize > 0) {
        const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
        assert(dict->dictionary);
        memmove(safeBuffer, previousDictEnd - dictSize, dictSize);
    }

    dict->dictionary = (const BYTE*)safeBuffer;
    dict->dictSize = (U32)dictSize;

    return dictSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4018(%rdi), %esi
cmpl %esi, %edx
cmovael %esi, %edx
movl $0x10000, %r15d         # imm = 0x10000
cmpl %r15d, %edx
cmovbl %edx, %r15d
testl %edx, %edx
je 0x13b16
addq 0x4008(%rbx), %rsi
movl %r15d, %edx
subq %rdx, %rsi
movq %r14, %rdi
callq 0x2260
movq %r14, 0x4008(%rbx)
movl %r15d, 0x4018(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shuffle2[P]nx2elf/lz4.c
// Function: LZ4_decompress_safe_usingDict
int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
{
    if (dictSize==0)
        return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
    if (dictStart+dictSize == dest) {
        if (dictSize >= 64 KB - 1) {
            return LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
        }
        assert(dictSize >= 0);
        return LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, (size_t)dictSize);
    }
    assert(dictSize >= 0);
    return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %r9d, %r9d
je 0x15f79
movslq %r9d, %rax
leaq (%r8,%rax), %r10
cmpq %rsi, %r10
jne 0x15f7f
cmpl $0xffff, %r9d           # imm = 0xFFFF
jge 0x15f88
movq %rax, %r8
popq %rbp
jmp 0x14a50
popq %rbp
jmp 0x2594
movq %rax, %r9
popq %rbp
jmp 0x3b41
popq %rbp
jmp 0x3407
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/sam.c
// Function: fail
static void HTS_FORMAT(HTS_PRINTF_FMT, 1, 2) fail(const char *fmt, ...)
{
    va_list args;

    fprintf(stderr, "Failed: ");
    va_start(args, fmt);
    vfprintf(stderr, fmt, args);
    va_end(args);
    fprintf(stderr, "\n");

    status = EXIT_FAILURE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x4a43
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0xb7596(%rip), %r15     # 0xbbfe0
movq (%r15), %rcx
leaq 0x9268d(%rip), %rdi     # 0x970e1
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0x49a0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x4690
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x4630
movl $0x1, 0xb7aa5(%rip)     # 0xbc544
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/sam.c
// Function: check_bam_aux_get
uint8_t *check_bam_aux_get(const bam1_t *aln, const char *tag, char type)
{
    uint8_t *p = bam_aux_get(aln, tag);
    if (p) {
        if (*p == type) return p;
        else fail("%s field of type '%c', expected '%c'", tag, *p, type);
    }
    else fail("can't find %s field", tag);

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
callq 0x31e40
testq %rax, %rax
je 0x6055
movq %rax, %rbx
movzbl (%rax), %edx
movsbl %bpl, %ecx
cmpl %ecx, %edx
jne 0x606a
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x91031(%rip), %rdi     # 0x9708d
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x49e0
jmp 0x604d
leaq 0x90ff7(%rip), %rdi     # 0x97068
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x49e0
jmp 0x604d
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/sam.c
// Function: test_text_file
static void test_text_file(const char *filename, int nexp)
{
    htsFile *in = hts_open(filename, "r");
    if (in) {
        kstring_t str = KS_INITIALIZE;
        int ret, n = 0;
        while ((ret = hts_getline(in, '\n', &str)) >= 0) {
            size_t len = strlen(str.s);
            n++;
            if (ret != len) fail("hts_getline read length %d (expected %zu)", ret, len);
        }
        if (ret != -1) fail("hts_getline got an error from %s", filename);
        if (n != nexp) fail("hts_getline read %d lines from %s (expected %d)", n, filename, nexp);

        hts_close(in);
        free(str.s);
    }
    else fail("can't open %s to read as text", filename);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x94938(%rip), %rsi     # 0x9f73b
callq 0x1b857
testq %rax, %rax
je 0xaeb2
movq %rax, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %rax, %rdi
movl $0xa, %esi
callq 0x1d0a1
movl %eax, %r12d
testl %eax, %eax
js 0xae83
movq %rsp, %r13
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
callq 0x41c0
movl %r12d, %ecx
cmpq %rcx, %rax
jne 0xae6d
movq %r14, %rdi
movl $0xa, %esi
movq %r13, %rdx
callq 0x1d0a1
movl %eax, %r12d
incl %r15d
testl %eax, %eax
jns 0xae3f
jmp 0xae86
leaq 0x8db42(%rip), %rdi     # 0x989b6
movl %r12d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x49e0
jmp 0xae51
xorl %r15d, %r15d
cmpl $-0x1, %r12d
jne 0xaed1
cmpl %ebp, %r15d
jne 0xaee4
movq %r14, %rdi
callq 0x1cac1
movq 0x10(%rsp), %rdi
callq 0x45c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8db78(%rip), %rdi     # 0x98a31
movq %rbx, %rsi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x49e0
leaq 0x8db08(%rip), %rdi     # 0x989e0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x49e0
jmp 0xae8c
leaq 0x8db16(%rip), %rdi     # 0x98a01
movl %r15d, %esi
movq %rbx, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x49e0
jmp 0xae91
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/sam.c
// Function: check_aux_count
static void check_aux_count(const bam1_t *aln, int expected, const char *what)
{
    const uint8_t *itr;
    int n = 0;
    for (itr = bam_aux_first(aln); itr; itr = bam_aux_next(aln, itr)) n++;
    if (n != expected)
        fail("%s has %d aux fields, expected %d", what, n, expected);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq 0x34050
xorl %ebp, %ebp
testq %rax, %rax
je 0xb450
incl %ebp
movq %r15, %rdi
movq %rax, %rsi
callq 0x3409e
jmp 0xb43c
cmpl %ebx, %ebp
jne 0xb45f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8c4a3(%rip), %rdi     # 0x97909
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x49e0
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/sam.c
// Function: check_int_B_array
static void check_int_B_array(bam1_t *aln, char *tag,
                             uint32_t nvals, int64_t *vals) {
    uint8_t *p;
    if ((p = check_bam_aux_get(aln, tag, 'B')) != NULL) {
        uint32_t i;

        if (bam_auxB_len(p) != nvals)
            fail("Wrong length reported for %s field, got %u, expected %u",
                 tag, bam_auxB_len(p), nvals);

        for (i = 0; i < nvals; i++) {
            if (bam_auxB2i(p, i) != vals[i]) {
                fail("Wrong value from bam_auxB2i for %s field index %u, "
                     "got %"PRId64" expected %"PRId64,
                     tag, i, bam_auxB2i(p, i), vals[i]);
            }
            if (bam_auxB2f(p, i) != (double) vals[i]) {
                fail("Wrong value from bam_auxB2f for %s field index %u, "
                     "got %f expected %f",
                     tag, i, bam_auxB2f(p, i), (double) vals[i]);
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movl $0x42, %edx
callq 0x602c
testq %rax, %rax
je 0xb54a
movq %rax, %r15
movq %rax, %rdi
callq 0x34bc3
cmpl %ebp, %eax
jne 0xb559
testl %ebp, %ebp
je 0xb54a
movl %ebp, %r12d
leaq 0x8c49a(%rip), %r13     # 0x97963
xorl %ebp, %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x34bdf
cmpq (%rbx,%rbp,8), %rax
jne 0xb500
movq %r15, %rdi
movl %ebp, %esi
callq 0x34c8f
xorps %xmm1, %xmm1
cvtsi2sdq (%rbx,%rbp,8), %xmm1
ucomisd %xmm1, %xmm0
jne 0xb522
jp 0xb522
incq %rbp
cmpq %rbp, %r12
jne 0xb4cb
jmp 0xb54a
movq %r15, %rdi
movl %ebp, %esi
callq 0x34bdf
movq (%rbx,%rbp,8), %r8
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x49e0
jmp 0xb4db
movq %r15, %rdi
movl %ebp, %esi
callq 0x34c8f
xorps %xmm1, %xmm1
cvtsi2sdq (%rbx,%rbp,8), %xmm1
leaq 0x8c46f(%rip), %rdi     # 0x979ab
movq %r14, %rsi
movl %ebp, %edx
movb $0x2, %al
callq 0x49e0
jmp 0xb4f6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x34bc3
leaq 0x8c3c3(%rip), %rdi     # 0x9792b
movq %r14, %rsi
movl %eax, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x49e0
jmp 0xb4b7
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/sam.c
// Function: test_update_int
static int test_update_int(bam1_t *aln,
                           const char target_id[2], int64_t target_val,
                           char expected_type,
                           const char next_id[2], int64_t next_val,
                           char next_type) {
    uint8_t *p;

    // Try updating target
    if (bam_aux_update_int(aln, target_id, target_val) < 0) {
        fail("update %.2s tag", target_id);
        return -1;
    }

    // Check it's there and has the right type and value
    p = bam_aux_get(aln, target_id);
    if (!p) {
        fail("find  %.2s tag", target_id);
        return -1;
    }
    if (*p != expected_type || bam_aux2i(p) != target_val) {
        fail("%.2s field is %c:%"PRId64"; expected %c:%"PRId64,
             target_id, *p, bam_aux2i(p), expected_type, target_val);
        return -1;
    }

    // If given, check that the next tag hasn't been clobbered by the
    // update above.
    if (!*next_id) return 0;
    p = bam_aux_get(aln, next_id);
    if (!p) {
        fail("find  %.2s tag after updating %.2s", next_id, target_id);
        return -1;
    }
    if (*p != next_type || bam_aux2i(p) != next_val) {
        fail("after updating %.2s to %"PRId64":"
             " %.2s field is %c:%"PRId64"; expected %c:%"PRId64,
             target_id, target_val,
             next_id, *p, bam_aux2i(p), next_type, next_val);
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
callq 0x343fa
testl %eax, %eax
js 0xb67a
movq %r13, %rdi
movq %rbx, %rsi
callq 0x31e40
testq %rax, %rax
je 0xb683
movq %rax, %r12
cmpb %bpl, (%rax)
jne 0xb64a
movq %r12, %rdi
callq 0x34aab
cmpq %r14, %rax
jne 0xb64a
xorl %ebp, %ebp
cmpb $0x0, (%r15)
je 0xb6af
movq %r13, %rdi
movq %r15, %rsi
callq 0x31e40
testq %rax, %rax
je 0xb696
movq %rax, %r13
movb 0x40(%rsp), %r12b
cmpb %r12b, (%rax)
jne 0xb611
movq %r13, %rdi
callq 0x34aab
cmpq (%rsp), %rax
je 0xb6af
movzbl %r12b, %r12d
movzbl (%r13), %ebp
movq %r13, %rdi
callq 0x34aab
leaq 0x8c40a(%rip), %rdi     # 0x97a33
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl %ebp, %r8d
movq %rax, %r9
xorl %eax, %eax
pushq (%rsp)
pushq %r12
callq 0x49e0
addq $0x10, %rsp
jmp 0xb6aa
movzbl %bpl, %ebp
movzbl (%r12), %r15d
movq %r12, %rdi
callq 0x34aab
leaq 0x8c3ed(%rip), %rdi     # 0x97a4f
movq %rbx, %rsi
movl %r15d, %edx
movq %rax, %rcx
movl %ebp, %r8d
movq %r14, %r9
xorl %eax, %eax
callq 0x49e0
jmp 0xb6aa
leaq 0x8c370(%rip), %rdi     # 0x979f1
jmp 0xb68a
leaq 0x8c377(%rip), %rdi     # 0x97a01
movq %rbx, %rsi
xorl %eax, %eax
callq 0x49e0
jmp 0xb6aa
leaq 0x8c373(%rip), %rdi     # 0x97a10
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x49e0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/sam.c
// Function: check_target_names
static int check_target_names(sam_hdr_t *header, int expected_n_targets,
                              const char **expected_targets,
                              const int   *expected_lengths) {
    int i;

    // Check consistency of target_names array
    if (!header->target_name) {
        fail("target_name is NULL");
        return -1;
    }
    if (!header->target_len) {
        fail("target_len is NULL");
        return -1;
    }
    if (header->n_targets != expected_n_targets) {
        fail("header->n_targets (%d) != expected_n_targets (%d)",
             header->n_targets, expected_n_targets);
        return -1;
    }
    for (i = 0; i < expected_n_targets; i++) {
        if (!header->target_name[i]
            || strcmp(header->target_name[i], expected_targets[i]) != 0) {
            fail("header->target_name[%d] (%s) != \"%s\"",
                 i, header->target_name[i] ? header->target_name[i] : "NULL",
                 expected_targets[i]);
            return -1;
        }
        if (header->target_len[i] != expected_lengths[i]) {
            fail("header->target_len[%d] (%d) != %d",
                 i, header->target_len[i], expected_lengths[i]);
            return -1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r13
testq %r13, %r13
je 0xbc5d
movq 0x10(%rdi), %rbp
testq %rbp, %rbp
je 0xbc66
movq %rsi, %rbx
movl (%rdi), %esi
cmpl $0x3, %esi
jne 0xbc76
movq %rdx, %r15
xorl %r14d, %r14d
movq (%r13,%r14,8), %r12
testq %r12, %r12
je 0xbc8b
movq (%rbx,%r14,8), %rsi
movq %r12, %rdi
callq 0x46c0
testl %eax, %eax
jne 0xbc92
movl (%rbp,%r14,4), %edx
movl (%r15,%r14,4), %ecx
cmpl %ecx, %edx
jne 0xbcac
incq %r14
cmpq $0x3, %r14
jne 0xbc29
xorl %eax, %eax
jmp 0xbcc2
leaq 0x8c4eb(%rip), %rdi     # 0x9814f
jmp 0xbc6d
leaq 0x8c4f6(%rip), %rdi     # 0x98163
xorl %eax, %eax
callq 0x49e0
jmp 0xbcbd
leaq 0x8c4f9(%rip), %rdi     # 0x98176
movl $0x3, %edx
xorl %eax, %eax
callq 0x49e0
jmp 0xbcbd
leaq 0x91de8(%rip), %r12     # 0x9da7a
movq (%rbx,%r14,8), %rcx
leaq 0x8c50b(%rip), %rdi     # 0x981a8
movl %r14d, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x49e0
jmp 0xbcbd
leaq 0x8c51a(%rip), %rdi     # 0x981cd
movl %r14d, %esi
xorl %eax, %eax
callq 0x49e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/sam.c
// Function: check_ref_lookup
static void check_ref_lookup(sam_hdr_t *header, const char *msg, ...) {
    const char *name;
    va_list args;
    va_start(args, msg);
    while ((name = va_arg(args, const char *)) != NULL) {
        int exp = va_arg(args, int);
        int tid = sam_hdr_name2tid(header, name);
        if (tid != exp)
            fail("%s: altname \"%s\" => %d (expected %d)", msg, name, tid, exp);
    }
    va_end(args);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xc1a0
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0x8c730(%rip), %r15     # 0x988f7
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0xc1e0
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0xc1ee
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r12
testq %r12, %r12
je 0xc245
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0xc20f
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0xc21d
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %ebp
movq %r14, %rdi
movq %r12, %rsi
callq 0x14732
cmpl %ebp, %eax
je 0xc1c7
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %eax, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x49e0
jmp 0xc1c7
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/sam.c
// Function: check_ref_lengths
static int check_ref_lengths(const sam_hdr_t *header,
                             const hts_pos_t *expected_lengths,
                             int num_refs, const char *hdr_name)
{
    int i;
    for (i = 0; i < num_refs; i++) {
        hts_pos_t ln = sam_hdr_tid2len(header, i);
        if (ln != expected_lengths[i]) {
            fail("Wrong length for %s ref %d : "
                 "expected %"PRIhts_pos" got %"PRIhts_pos"\n",
                 hdr_name, i, expected_lengths[i], ln);
            return -1;
        }
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorl %r14d, %r14d
movq %r12, %rdi
movl %r14d, %esi
callq 0x148c3
movq (%r15,%r14,8), %rcx
cmpq %rcx, %rax
jne 0xc294
incq %r14
cmpq $0x4, %r14
jne 0xc269
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8caae(%rip), %rdi     # 0x98d49
movq %rbx, %rsi
movl %r14d, %edx
movq %rax, %r8
xorl %eax, %eax
callq 0x49e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xc288
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/sam.c
// Function: test_parse_decimal1
static void test_parse_decimal1(long long exp, const char *str, size_t exp_consumed, int flags, const char *warning)
{
    if (warning) fprintf(stderr, "(Expect %s message for \"%s\")\n", warning, str);

    long long val = hts_parse_decimal(str, NULL, flags);
    if (val != exp) fail("hts_parse_decimal(\"%s\", NULL, %d) returned %lld, expected %lld", str, flags, val, exp);

    char *end;
    val = hts_parse_decimal(str, &end, flags);
    if (val != exp) fail("hts_parse_decimal(\"%s\", ..., %d) returned %lld, expected %lld", str, flags, val, exp);
    size_t consumed = end - str;
    if (consumed != exp_consumed) fail("hts_parse_decimal(\"%s\", ..., %d) consumed %zu chars, expected %zu", str, flags, consumed, exp_consumed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %r8, %r8
jne 0xc303
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x21262
cmpq %r15, %rax
jne 0xc323
movq %rsp, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x21262
cmpq %r15, %rax
jne 0xc33e
movq (%rsp), %rcx
subq %r14, %rcx
cmpq %rbx, %rcx
jne 0xc359
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xafcd6(%rip), %rax     # 0xbbfe0
movq (%rax), %rdi
leaq 0x8cb17(%rip), %rsi     # 0x98e2b
movq %r8, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x4700
jmp 0xc2c9
leaq 0x8cb1f(%rip), %rdi     # 0x98e49
movq %r14, %rsi
movl %ebp, %edx
movq %rax, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x49e0
jmp 0xc2da
leaq 0x8cb43(%rip), %rdi     # 0x98e88
movq %r14, %rsi
movl %ebp, %edx
movq %rax, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x49e0
jmp 0xc2ec
leaq 0x8cb66(%rip), %rdi     # 0x98ec6
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %r8
xorl %eax, %eax
callq 0x49e0
jmp 0xc2f8
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/sam.c
// Function: read_data_block
static int read_data_block(const char *in_name, samFile *fp_in,
                           const char *out_name, samFile *fp_out,
                           sam_hdr_t *header, bam1_t *recs, size_t max_recs,
                           uint8_t *buffer, size_t bufsz, size_t *nrecs_out) {
    size_t buff_used = 0, nrecs;
    uint32_t new_m_data;
    int ret = -1, res = -1;

    for (nrecs = 0; nrecs < max_recs; nrecs++) {
        bam_set_mempolicy(&recs[nrecs],
                          BAM_USER_OWNS_STRUCT|BAM_USER_OWNS_DATA);

        recs[nrecs].data = &buffer[buff_used];
        recs[nrecs].m_data = bufsz - buff_used;

        res = sam_read1(fp_in, header, &recs[nrecs]);
        if (res < 0) break; // EOF or error

        if (fp_out) {
            if (sam_write1(fp_out, header, &recs[nrecs]) < 0) {
                nrecs++; // To return correct count
                fail("sam_write1() to \"%s\"", out_name);
                goto out;
            }
        }

        if ((bam_get_mempolicy(&recs[nrecs]) & BAM_USER_OWNS_DATA) == 0) {
            continue;  // Data not put in buffer
        }

        new_m_data = ((uint32_t) recs[nrecs].l_data + 7) & (~7U);
        if (new_m_data < recs[nrecs].m_data) recs[nrecs].m_data = new_m_data;

        buff_used += recs[nrecs].m_data;
    }
    if (res < -1) {
        fail("sam_read1() from \"%s\" failed", in_name);
    } else {
        ret = 0;
    }

 out:
    *nrecs_out = nrecs;
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, (%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movl $0x1, %r14d
xorl %ebp, %ebp
orb $0x3, 0x48(%r15)
movq 0x50(%rsp), %rax
addq %rbp, %rax
movq %rax, 0x38(%r15)
movl $0x249f0, %eax          # imm = 0x249F0
subl %ebp, %eax
movl %eax, 0x44(%r15)
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2f8d9
movl %eax, %ebx
testl %eax, %eax
js 0xc421
testq %r13, %r13
je 0xc3e7
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x330c3
testl %eax, %eax
js 0xc450
testb $0x2, 0x48(%r15)
je 0xc409
movl 0x40(%r15), %eax
addl $0x7, %eax
andl $-0x8, %eax
cmpl 0x44(%r15), %eax
jae 0xc402
movl %eax, 0x44(%r15)
movl 0x44(%r15), %eax
addq %rax, %rbp
incq %r14
addq $0x50, %r15
cmpq $0x3e9, %r14            # imm = 0x3E9
jne 0xc39e
movl $0x3e8, %r14d           # imm = 0x3E8
jmp 0xc424
decq %r14
xorl %eax, %eax
cmpl $-0x2, %ebx
jle 0xc442
movq 0x58(%rsp), %rcx
movq %r14, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8cc0e(%rip), %rdi     # 0x99057
movq 0x8(%rsp), %rsi
jmp 0xc45b
leaq 0x8cbeb(%rip), %rdi     # 0x99042
movq (%rsp), %rsi
xorl %eax, %eax
callq 0x49e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xc42b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.7/tsd.c
// Function: merge_sort
void merge_sort(int low, int high) 
{ 
    // calculating mid point of array 
    int mid = low + (high - low) / 2; 
    if (low < high) { 
  
        // calling first half 
        merge_sort(low, mid); 
  
        // calling second half 
        merge_sort(mid + 1, high); 
  
        // merging the two halves 
        merge(low, mid, high); 
    } 
}

// Assembly:
movl %esi, %eax
subl %edi, %eax
jle 0x1476
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
leal (%r12,%r14), %r15d
movl %r15d, %esi
callq 0x1425
leal (%r12,%r14), %edi
incl %edi
movl %ebx, %esi
callq 0x1425
movl %r14d, %edi
movl %r15d, %esi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1274
retq
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.7/tsd.c
// Function: create_random_array
void create_random_array(){
	time_t t;

	srand((unsigned) time(&t));

	int i;
	for(i = 0; i < MAX; ++i){
		a[i] = rand() % 100;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x18(%rbp), %rdi
callq 0x10b0
movl %eax, %edi
callq 0x1080
xorl %ebx, %ebx
leaq 0x2a94(%rip), %r14      # 0x40d0
callq 0x1120
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
movl %eax, (%rbx,%r14)
addq $0x4, %rbx
cmpq $0x50, %rbx
jne 0x163c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.7/tsd.c
// Function: main
int main ()
{
	int i;

	create_random_array();

	pthread_t threads[THREAD_MAX];
	/* Create a key to associate thread log file pointers in
	thread-specific data. Use close_thread_log to clean up the file
	pointers. */ 
	pthread_key_create (&thread_log_key, close_thread_log);
	/* Create threads to do the work. */
	for (i = 0; i < THREAD_MAX; ++i)
		pthread_create (&(threads[i]), NULL, merge_sort_multithreading, NULL);
	/* Wait for all threads to finish. */
	for (i = 0; i < THREAD_MAX; ++i)
		pthread_join (threads[i], NULL);

	merge(0, (MAX / 2 - 1) / 2, MAX / 2 - 1); 
    merge(MAX / 2, MAX/2 + (MAX-1-MAX/2)/2, MAX - 1); 
    merge(0, (MAX - 1)/2, MAX - 1); 

	for (i = 0; i < MAX; ++i)
		printf("%d\n", a[i]);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0x1618
leaq 0x2a38(%rip), %rdi      # 0x40c4
leaq -0x429(%rip), %rsi      # 0x126a
callq 0x1070
xorl %r14d, %r14d
leaq -0x22b(%rip), %rbx      # 0x1477
leaq (%r14,%rbp), %rdi
addq $-0x40, %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x10d0
addq $0x8, %r14
cmpq $0x20, %r14
jne 0x16a2
xorl %ebx, %ebx
movq -0x40(%rbp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1110
incq %rbx
cmpq $0x4, %rbx
jne 0x16c2
xorl %edi, %edi
movl $0x4, %esi
movl $0x9, %edx
callq 0x1274
movl $0xa, %edi
movl $0xe, %esi
movl $0x13, %edx
callq 0x1274
xorl %edi, %edi
movl $0x9, %esi
movl $0x13, %edx
callq 0x1274
leaq 0x29bc(%rip), %r14      # 0x40d0
leaq 0x97d(%rip), %rbx       # 0x2098
xorl %r15d, %r15d
movl (%r15,%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1060
addq $0x4, %r15
cmpq $0x50, %r15
jne 0x171e
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/zic.c
// Function: error
static void
error(string)
const char * const	string;
{
	/*
	** Match the format of "cc" to allow sh users to
	**	zic ... 2>&1 | error -t "*" -v
	** on BSD systems.
	*/
	(void) fprintf(stderr, _("\"%s\", line %d: %s"),
		filename, linenum, string);
	if (rfilename != NULL)
		(void) fprintf(stderr, _(" (rule from \"%s\", line %d)"),
			rfilename, rlinenum);
	(void) fprintf(stderr, "\n");
	++errors;
}

// Assembly:
pushq %rbx
movq %rdi, %r8
movq 0xbced(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
movq 0xbf13(%rip), %rdx      # 0xe228
movl 0xbf15(%rip), %ecx      # 0xe230
leaq 0x7fdb(%rip), %rsi      # 0xa2fd
xorl %eax, %eax
callq 0x21c0
movq 0xbf08(%rip), %rdx      # 0xe238
testq %rdx, %rdx
jne 0x2348
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x2150
incl 0xbebe(%rip)            # 0xe204
popq %rbx
retq
movq (%rbx), %rdi
movl 0xbeef(%rip), %ecx      # 0xe240
leaq 0x7fb7(%rip), %rsi      # 0xa30f
xorl %eax, %eax
callq 0x21c0
jmp 0x2335
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/zic.c
// Function: warning
static void
warning(string)
const char * const	string;
{
	char *	cp;

	cp = ecpyalloc(_("warning: "));
	cp = ecatalloc(cp, string);
	error(cp);
	ifree(cp);
	--errors;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4a3a(%rip), %rdi      # 0xa2d9
callq 0x9c6b
movq %rax, %r14
movq %rax, %rdi
callq 0x58e3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9bf4
movq %rax, %rbx
movq %rax, %rdi
callq 0x58e3
movq %rbx, %rdi
callq 0x2300
movq %rbx, %rdi
callq 0x9c75
decl 0x8929(%rip)            # 0xe204
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/zic.c
// Function: itsdir
static int
itsdir(name)
const char * const	name;
{
	register char *	myname;
	register int	accres;

	myname = ecpyalloc(name);
	myname = ecatalloc(myname, "/.");
	accres = access(myname, F_OK);
	ifree(myname);
	return accres == 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x9c6b
movq %rax, %rbx
movq %rax, %rdi
callq 0x58e3
leaq 0x4a69(%rip), %rsi      # 0xa375
movq %rbx, %rdi
callq 0x9bf4
movq %rax, %rbx
movq %rax, %rdi
callq 0x58e3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2250
movl %eax, %ebp
movq %rbx, %rdi
callq 0x9c75
xorl %eax, %eax
testl %ebp, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/zic.c
// Function: mkdirs
static int
mkdirs(argname)
char *		argname;
{
	register char *	name;
	register char *	cp;

	if (argname == NULL || *argname == '\0')
		return 0;
	cp = name = ecpyalloc(argname);
	while ((cp = strchr(cp + 1, '/')) != 0) {
		*cp = '\0';
#ifndef unix
		/*
		** DOS drive specifier?
		*/
		if (isalpha((unsigned char) name[0]) &&
			name[1] == ':' && name[2] == '\0') {
				*cp = '/';
				continue;
		}
#endif /* !defined unix */
		if (!itsdir(name)) {
			/*
			** It doesn't seem to exist, so we try to create it.
			** Creation may fail because of the directory being
			** created by some other multiprocessor, so we get
			** to do extra checking.
			*/
			if (mkdir(name, MKDIR_UMASK) != 0) {
				const char *e = strerror(errno);

				if (errno != EEXIST || !itsdir(name)) {
					(void) fprintf(stderr,
_("%s: Can't create directory %s: %s\n"),
						progname, name, e);
					ifree(name);
					return -1;
				}
			}
		}
		*cp = '/';
	}
	ifree(name);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x59f1
cmpb $0x0, (%rdi)
je 0x59f1
callq 0x9c6b
movq %rax, %rbx
movq %rax, %rdi
callq 0x58e3
movq %rbx, %rdi
incq %rdi
movl $0x2f, %esi
callq 0x2100
xorl %ebp, %ebp
testq %rax, %rax
je 0x59e9
movq %rax, %r14
movb $0x0, (%r14)
movq %rbx, %rdi
callq 0x58f2
testl %eax, %eax
jne 0x59cd
movq %rbx, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x2090
testl %eax, %eax
je 0x59cd
callq 0x2050
movq %rax, %r12
movl (%rax), %edi
callq 0x22d0
movq %rax, %r15
cmpl $0x11, (%r12)
jne 0x59fc
movq %rbx, %rdi
callq 0x58f2
testl %eax, %eax
je 0x59fc
movb $0x2f, (%r14)
incq %r14
movq %r14, %rdi
movl $0x2f, %esi
callq 0x2100
movq %rax, %r14
testq %rax, %rax
jne 0x5987
movq %rbx, %rdi
callq 0x9c75
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x85f5(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x87c3(%rip), %rdx      # 0xe1d0
leaq 0x4964(%rip), %rsi      # 0xa378
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x21c0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x59e9
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/zic.c
// Function: leapadd
static void
leapadd(t, positive, rolling, count)
const zic_t	t;
const int	positive;
const int	rolling;
int		count;
{
	register int	i, j;

	if (leapcnt + (positive ? count : 1) > TZ_MAX_LEAPS) {
		error(_("too many leap seconds"));
		exit(EXIT_FAILURE);
	}
	for (i = 0; i < leapcnt; ++i)
		if (t <= trans[i]) {
			if (t == trans[i]) {
				error(_("repeated leap second moment"));
				exit(EXIT_FAILURE);
			}
			break;
		}
	do {
		for (j = leapcnt; j > i; --j) {
			trans[j] = trans[j - 1];
			corr[j] = corr[j - 1];
			roll[j] = roll[j - 1];
		}
		trans[i] = t;
		corr[i] = positive ? 1L : eitol(-count);
		roll[i] = rolling;
		++leapcnt;
	} while (positive && --count != 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x7c3b(%rip), %r8d      # 0xe3bc
testl %esi, %esi
movl $0x1, %eax
cmovnel %ecx, %eax
addl %r8d, %eax
cmpl $0x32, %eax
jg 0x6861
leaq 0x7c22(%rip), %rax      # 0xe3c0
xorl %r10d, %r10d
testl %r8d, %r8d
jle 0x67c5
movq %rax, %r9
cmpq %rdi, (%r9)
jge 0x67bf
incq %r10
addq $0x8, %r9
cmpq %r10, %r8
jne 0x67a9
movl %r8d, %r10d
jmp 0x67c5
je 0x6866
movl %r10d, %r8d
movslq 0x7bed(%rip), %r9       # 0xe3bc
movslq %r10d, %rbx
cmpl $0x1, %ecx
sete %bpl
leaq 0x7d70(%rip), %r11      # 0xe550
leaq 0x7ef9(%rip), %r10      # 0xe6e0
cmpl %r9d, %r8d
jge 0x6816
movq %r9, %r14
movq -0x8(%rax,%r14,8), %r15
movq %r15, (%rax,%r14,8)
movq -0x8(%r11,%r14,8), %r15
movq %r15, (%r11,%r14,8)
movb -0x1(%r14,%r10), %r15b
movb %r15b, (%r14,%r10)
leaq -0x1(%r14), %r15
movq %r15, %r14
cmpq %rbx, %r15
jg 0x67ef
movq %rdi, (%rax,%r8,8)
testl %esi, %esi
je 0x683f
movq $0x1, (%r11,%r8,8)
movb %dl, (%r8,%r10)
incq %r9
movl %r9d, 0x7b88(%rip)      # 0xe3bc
testb $0x1, %bpl
movb $0x1, %bpl
je 0x67e7
jmp 0x6856
negl %ecx
movslq %ecx, %rax
movq %rax, (%r11,%r8,8)
movb %dl, (%r8,%r10)
leal 0x1(%r9), %eax
movl %eax, 0x7b66(%rip)      # 0xe3bc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x275a
callq 0x2745
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/zic.c
// Function: doabbr
static void
doabbr(abbr, format, letters, isdst, doquotes)
char * const		abbr;
const char * const	format;
const char * const	letters;
const int		isdst;
const int		doquotes;
{
	register char *	cp;
	register char *	slashp;
	register int	len;

	slashp = strchr(format, '/');
	if (slashp == NULL) {
		if (letters == NULL)
			(void) strcpy(abbr, format);
		else	(void) sprintf(abbr, format, letters);
	} else if (isdst) {
		(void) strcpy(abbr, slashp + 1);
	} else {
		if (slashp > format)
			(void) strncpy(abbr, format,
				(unsigned) (slashp - format));
		abbr[slashp - format] = '\0';
	}
	if (!doquotes)
		return;
	for (cp = abbr; *cp != '\0'; ++cp)
		if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ", *cp) == NULL &&
			strchr("abcdefghijklmnopqrstuvwxyz", *cp) == NULL)
				break;
	len = strlen(abbr);
	if (len > 0 && *cp == '\0')
		return;
	abbr[len + 2] = '\0';
	abbr[len + 1] = '>';
	for ( ; len > 0; --len)
		abbr[len] = abbr[len - 1];
	abbr[0] = '<';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2f, %esi
callq 0x2100
testq %rax, %rax
je 0x68a7
testl %r12d, %r12d
je 0x68c5
incq %rax
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x68be
movq %rbx, %rdi
movq %r14, %rsi
testq %r15, %r15
je 0x68be
movq %r15, %rdx
xorl %eax, %eax
callq 0x2290
jmp 0x68e3
callq 0x2080
jmp 0x68e3
movq %rax, %r15
subq %r14, %r15
jbe 0x68de
subl %r14d, %eax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2060
movb $0x0, (%rbx,%r15)
testl %ebp, %ebp
je 0x69a7
movb (%rbx), %al
testb %al, %al
setne %r12b
je 0x6941
leaq 0x1(%rbx), %r13
leaq 0x41ee(%rip), %r14      # 0xaaee
leaq 0x4202(%rip), %r15      # 0xab09
movsbl %al, %ebp
movl $0x1b, %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x2160
testq %rax, %rax
jne 0x6932
movl $0x1b, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x2160
testq %rax, %rax
je 0x6941
movb (%r13), %al
incq %r13
testb %al, %al
setne %r12b
jne 0x6907
movq %rbx, %rdi
callq 0x20e0
testl %eax, %eax
setg %cl
notb %r12b
testb %cl, %r12b
jne 0x69a7
movq %rax, %rcx
shlq $0x20, %rcx
movabsq $0x200000000, %rdx      # imm = 0x200000000
addq %rcx, %rdx
sarq $0x20, %rdx
movb $0x0, (%rbx,%rdx)
movabsq $0x100000000, %rdx      # imm = 0x100000000
addq %rcx, %rdx
sarq $0x20, %rdx
movb $0x3e, (%rbx,%rdx)
testl %eax, %eax
jle 0x69a4
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
incq %rax
movb -0x2(%rbx,%rax), %cl
movb %cl, -0x1(%rbx,%rax)
decq %rax
cmpq $0x1, %rax
jg 0x6993
movb $0x3c, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/zic.c
// Function: addtt
static void
addtt(starttime, type)
const zic_t	starttime;
int		type;
{
	if (starttime <= min_time ||
		(timecnt == 1 && attypes[0].at < min_time)) {
		gmtoffs[0] = gmtoffs[type];
		isdsts[0] = isdsts[type];
		ttisstds[0] = ttisstds[type];
		ttisgmts[0] = ttisgmts[type];
		if (abbrinds[type] != 0)
			(void) strcpy(chars, &chars[abbrinds[type]]);
		abbrinds[0] = 0;
		charcnt = strlen(chars) + 1;
		typecnt = 1;
		timecnt = 0;
		type = 0;
	}
	if (timecnt >= TZ_MAX_TIMES) {
		error(_("too many transitions?!"));
		exit(EXIT_FAILURE);
	}
	attypes[timecnt].at = starttime;
	attypes[timecnt].type = type;
	++timecnt;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x753f(%rip), %eax      # 0xe248
shlq $0x3f, %rax
cmpq %rdi, %rax
jge 0x6d2c
cmpl $0x1, 0x79fb(%rip)      # 0xe714
jne 0x6dc1
cmpq %rax, 0x864a(%rip)      # 0xf370
jge 0x6dc1
movslq %esi, %rax
leaq 0x79fa(%rip), %rcx      # 0xe730
movq (%rcx,%rax,8), %rcx
movq %rcx, 0x79ef(%rip)      # 0xe730
leaq 0x81e8(%rip), %rcx      # 0xef30
movb (%rax,%rcx), %cl
movb %cl, 0x81df(%rip)       # 0xef30
leaq 0x8418(%rip), %rcx      # 0xf170
movb (%rax,%rcx), %cl
movb %cl, 0x840f(%rip)       # 0xf170
leaq 0x8508(%rip), %rcx      # 0xf270
movb (%rax,%rcx), %cl
movb %cl, 0x84ff(%rip)       # 0xf270
leaq 0x82f8(%rip), %rcx      # 0xf070
movzbl (%rax,%rcx), %esi
testq %rsi, %rsi
je 0x6d90
leaq 0x82a8(%rip), %rdi      # 0xf030
addq %rdi, %rsi
callq 0x2080
movb $0x0, 0x82d9(%rip)      # 0xf070
leaq 0x8292(%rip), %rdi      # 0xf030
callq 0x20e0
incl %eax
movl %eax, 0x7971(%rip)      # 0xe71c
movl $0x1, 0x7963(%rip)      # 0xe718
movl $0x0, 0x7955(%rip)      # 0xe714
xorl %esi, %esi
movslq 0x794c(%rip), %rax      # 0xe714
cmpq $0x4b0, %rax            # imm = 0x4B0
jge 0x6df1
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x8592(%rip), %rdx      # 0xf370
movq %rbx, (%rcx,%rdx)
movb %sil, 0x8(%rcx,%rdx)
incl %eax
movl %eax, 0x7925(%rip)      # 0xe714
popq %rbx
retq
callq 0x27ed
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/zic.c
// Function: stringoffset
static int
stringoffset(result, offset)
char *	result;
long	offset;
{
	register int	hours;
	register int	minutes;
	register int	seconds;

	result[0] = '\0';
	if (offset < 0) {
		(void) strcpy(result, "-");
		offset = -offset;
	}
	seconds = offset % SECSPERMIN;
	offset /= SECSPERMIN;
	minutes = offset % MINSPERHOUR;
	offset /= MINSPERHOUR;
	hours = offset;
	if (hours >= HOURSPERDAY) {
		result[0] = '\0';
		return -1;
	}
	(void) sprintf(end(result), "%d", hours);
	if (minutes != 0 || seconds != 0) {
		(void) sprintf(end(result), ":%02d", minutes);
		if (seconds != 0)
			(void) sprintf(end(result), ":%02d", seconds);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, (%rdi)
testq %rsi, %rsi
jns 0x6e15
movw $0x2d, (%r14)
negq %rbx
movabsq $-0x7777777777777777, %rcx # imm = 0x8888888888888889
movq %rbx, %rax
mulq %rcx
movq %rdx, %r15
shrq $0x5, %r15
movabsq $0x888888888888889, %rcx # imm = 0x888888888888889
movq %r15, %rax
mulq %rcx
movq %rdx, %rcx
movq %rbx, %rax
shrq $0x4, %rax
movabsq $0x91a2b3c4d5e6f81, %rdx # imm = 0x91A2B3C4D5E6F81
mulq %rdx
movq %rdx, %r12
shrq $0x3, %r12
cmpl $0x18, %r12d
jl 0x6e6b
movb $0x0, (%r14)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x6ee7
imulq $0x3c, %r15, %rax
subq %rax, %rbx
shrq %rcx
imulq $0x3c, %rcx, %rax
subq %rax, %r15
movq %r14, %rdi
callq 0x20e0
leaq (%rax,%r14), %rdi
leaq 0x3c5c(%rip), %rsi      # 0xaaeb
xorl %ebp, %ebp
movl %r12d, %edx
xorl %eax, %eax
callq 0x2290
movq %r15, %rax
orq %rbx, %rax
je 0x6ee7
movq %r14, %rdi
callq 0x20e0
leaq (%rax,%r14), %rdi
leaq 0x3c24(%rip), %rsi      # 0xaada
xorl %ebp, %ebp
movl %r15d, %edx
xorl %eax, %eax
callq 0x2290
testq %rbx, %rbx
je 0x6ee7
movq %r14, %rdi
callq 0x20e0
addq %rax, %r14
leaq 0x3c01(%rip), %rsi      # 0xaada
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x2290
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aegis256/aesni/encrypt.c
// Function: aegis256_tag_generation
void aegis256_tag_generation(unsigned long long msglen, unsigned long long adlen, unsigned char maclen, unsigned char *mac, __m128i *state)
{
       int i;

        __m128i  tmp;
        __m128i  msgtmp;
        unsigned char t[16], tt[16];

        for (i = 0; i < 16; i++) tt[i] = 0;
	((unsigned long long*)tt)[0] = adlen  << 3;
	((unsigned long long*)tt)[1] = msglen << 3;
	msgtmp = _mm_load_si128((__m128i*)tt);

        msgtmp = _mm_xor_si128(msgtmp, state[3]);

        for (i = 0; i < 7; i++) {  
             //state update function
             tmp = state[5];
             state[5] = _mm_aesenc_si128(state[4],state[5]);
             state[4] = _mm_aesenc_si128(state[3],state[4]);
             state[3] = _mm_aesenc_si128(state[2],state[3]);
             state[2] = _mm_aesenc_si128(state[1],state[2]);
             state[1] = _mm_aesenc_si128(state[0],state[1]);
             state[0] = _mm_aesenc_si128(tmp,state[0]);

            //xor "msg" with state[0]
             state[0] = _mm_xor_si128(state[0], msgtmp);
        }

        state[5] = _mm_xor_si128(state[5], state[4]);
        state[5] = _mm_xor_si128(state[5], state[3]);
        state[5] = _mm_xor_si128(state[5], state[2]);
        state[5] = _mm_xor_si128(state[5], state[1]);
        state[5] = _mm_xor_si128(state[5], state[0]);

        _mm_store_si128((__m128i*)t, state[5]);
        //in this program, the mac length is assumed to be multiple of bytes
        memcpy(mac,t,maclen);
}

// Assembly:
vmovq %rdi, %xmm0
vmovq %rsi, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vpsllq $0x3, %xmm0, %xmm4
vmovdqa (%r8), %xmm1
vmovdqa 0x10(%r8), %xmm0
vmovdqa 0x20(%r8), %xmm2
vmovdqa 0x30(%r8), %xmm3
vpxor %xmm4, %xmm3, %xmm5
vmovdqa 0x50(%r8), %xmm6
vmovdqa 0x40(%r8), %xmm4
movl $0x7, %eax
vaesenc %xmm6, %xmm4, %xmm7
vaesenc %xmm4, %xmm3, %xmm4
vaesenc %xmm3, %xmm2, %xmm3
vaesenc %xmm2, %xmm0, %xmm2
vaesenc %xmm0, %xmm1, %xmm0
vaesenc %xmm1, %xmm6, %xmm1
vpxor %xmm1, %xmm5, %xmm1
vmovdqa %xmm7, %xmm6
decl %eax
jne 0x1265
subq $0x18, %rsp
vmovdqa %xmm4, 0x40(%r8)
vmovdqa %xmm3, 0x30(%r8)
vmovdqa %xmm2, 0x20(%r8)
vmovdqa %xmm0, 0x10(%r8)
vmovdqa %xmm1, (%r8)
vpxor %xmm7, %xmm4, %xmm4
vpternlogq $0x96, %xmm4, %xmm3, %xmm2
vpternlogq $0x96, %xmm2, %xmm1, %xmm0
vmovdqa %xmm0, 0x50(%r8)
movq %rsp, %rsi
vmovdqa %xmm0, (%rsi)
movzbl %dl, %edx
movq %rcx, %rdi
callq 0x1070
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/timocramer[P]thinklight-fun/tl-morsestrobo.c
// Function: main
int main(int argc, char **argv) {
	if(tl_init()) {
		fputs("Light Interface cannot be opened!\n", stderr);
		return 1;
	}
	if(tl_status() == TL_ON)
		initial_status = TL_ON;
	
	if(lock()) {
		if(errno != EEXIST)
			perror("open " LOCKFILE);
		else
			fputs("Thinklight is in use!\n", stderr);
		return 1;
	}
	
	install_signal_handler();
	
#ifdef MORSE
	if(argc < 2) {
		fputs(argv[0], stderr);
		fputs(": No arguments!\n", stderr);
		goto finish;
	}
	
	/* morse the arguments */
	int i = 1;
	while(1) {
		morse_string(argv[i]);
		
		++i;
		
		if(i >= argc) /* is it the last argument? */
			break;
		morse_char(' ');
	}
	
	/* save the initial status */
	if(initial_status == TL_ON)
		tl_on();
	else
		tl_off();
	
	finish:
	tl_deinit();
	unlock();
#elif defined STROBO
	/* use argc and argv so the compiler doesn't complain */
	(void) argc;
	(void) argv;
	
	while(1) {
		tl_toggle();
		usleep(DELAY);
	}
	/* deinit and unlock happens in the signal handler */
#endif
	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movl %edi, %r14d
callq 0x16e4
testl %eax, %eax
jne 0x13a8
callq 0x1780
cmpl $0x1, %eax
jne 0x129e
movb $0x1, 0x2dfa(%rip)      # 0x4098
leaq 0xf8c(%rip), %rdi       # 0x2231
movl $0xc1, %esi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x10c0
testl %eax, %eax
js 0x13af
movl %eax, %edi
callq 0x1090
leaq 0x3f1(%rip), %rax       # 0x16bd
leaq 0x8(%rsp), %rdi
movq %rax, -0x8(%rdi)
movl $0x0, 0x80(%rdi)
callq 0x10b0
movq %rsp, %rsi
movl $0x2, %edi
xorl %edx, %edx
callq 0x1050
cmpl $-0x1, %eax
je 0x139e
movq %rsp, %rsi
movl $0xf, %edi
xorl %edx, %edx
callq 0x1050
cmpl $-0x1, %eax
je 0x139e
cmpl $0x2, %r14d
jl 0x13c0
decl %r14d
movl $0x1, %r15d
movq (%rbx,%r15,8), %r12
movb (%r12), %al
testb %al, %al
je 0x135a
incq %r12
movsbl %al, %edi
callq 0x13dd
cmpb $0x0, (%r12)
je 0x134f
movl $0x53020, %edi          # imm = 0x53020
callq 0x10f0
movb (%r12), %al
incq %r12
testb %al, %al
jne 0x1336
cmpq %r14, %r15
je 0x136e
incq %r15
movl $0x20, %edi
callq 0x13dd
jmp 0x1327
cmpb $0x1, 0x2d23(%rip)      # 0x4098
jne 0x137e
callq 0x1720
jmp 0x1383
callq 0x1750
callq 0x1704
callq 0x169c
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x113c
jmp 0x1314
callq 0x1110
jmp 0x13d6
callq 0x1030
cmpl $0x11, (%rax)
jne 0x13ca
callq 0x1126
jmp 0x13d6
movq %rbx, %rdi
callq 0x1158
jmp 0x1383
leaq 0xd3a(%rip), %rdi       # 0x210b
callq 0x10d0
movl $0x1, %eax
jmp 0x138f