LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/sam.c
// Function: test_parse_decimal
static void test_parse_decimal(void)
{
    test_parse_decimal1(37, "+37", 3, 0, NULL);
    test_parse_decimal1(-1001, " \t -1,001x", 9, HTS_PARSE_THOUSANDS_SEP, "trailing 'x'");
    test_parse_decimal1(LLONG_MAX, "+9223372036854775807", 20, 0, NULL);
    test_parse_decimal1(LLONG_MIN, "-9,223,372,036,854,775,808", 26, HTS_PARSE_THOUSANDS_SEP, NULL);
    test_parse_decimal1(1500, "1.5e3", 5, 0, NULL);
    test_parse_decimal1(1500, "1.5e+3k", 6, 0, "trailing 'k'");
    test_parse_decimal1(1500000000, "1.5G", 4, 0, NULL);
    test_parse_decimal1(12345, "12.345k", 7, 0, NULL);
    test_parse_decimal1(12345, "12.3456k", 8, 0, "dropped fraction");
    test_parse_decimal1(0, "A", 0, 0, "invalid numeric");
    test_parse_decimal1(0, "G", 0, 0, "invalid numeric");
    test_parse_decimal1(0, " +/-", 0, 0, "invalid numeric");
    test_parse_decimal1(0, " \t -.e+9999", 0, 0, "invalid numeric");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x25, %edi
leaq 0xe87a4(%rip), %rsi     # 0xf2724
movl $0x3, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xe6a0
movq $-0x3e9, %rdi           # imm = 0xFC17
leaq 0xe8789(%rip), %rsi     # 0xf2728
movl $0x9, %edx
movl $0x1, %ecx
leaq 0xe8783(%rip), %r8      # 0xf2733
callq 0xe6a0
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
leaq 0xe877a(%rip), %rsi     # 0xf2740
movl $0x14, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xe6a0
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
leaq 0xe876d(%rip), %rsi     # 0xf2755
movl $0x1a, %edx
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xe6a0
movl $0x5dc, %edi            # imm = 0x5DC
leaq 0xe8768(%rip), %rsi     # 0xf2770
movl $0x5, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xe6a0
movl $0x5dc, %edi            # imm = 0x5DC
leaq 0xe8751(%rip), %rsi     # 0xf2776
movl $0x6, %edx
xorl %ecx, %ecx
leaq 0xe874b(%rip), %r8      # 0xf277e
callq 0xe6a0
movl $0x59682f00, %edi       # imm = 0x59682F00
leaq 0xe8747(%rip), %rsi     # 0xf278b
movl $0x4, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xe6a0
movl $0x3039, %edi           # imm = 0x3039
leaq 0xe872f(%rip), %rsi     # 0xf2790
movl $0x7, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xe6a0
movl $0x3039, %edi           # imm = 0x3039
leaq 0xe871a(%rip), %rsi     # 0xf2798
movl $0x8, %edx
xorl %ecx, %ecx
leaq 0xe8715(%rip), %r8      # 0xf27a1
callq 0xe6a0
xorl %eax, %eax
movl %eax, %edx
leaq 0xef0e7(%rip), %rsi     # 0xf9183
xorl %ecx, %ecx
leaq 0xe870d(%rip), %r8      # 0xf27b2
movq %rdx, %rdi
callq 0xe6a0
xorl %eax, %eax
movl %eax, %edx
leaq 0xe86d6(%rip), %rsi     # 0xf278e
xorl %ecx, %ecx
leaq 0xe86f1(%rip), %r8      # 0xf27b2
movq %rdx, %rdi
callq 0xe6a0
xorl %eax, %eax
movl %eax, %edx
leaq 0xe86ee(%rip), %rsi     # 0xf27c2
xorl %ecx, %ecx
leaq 0xe86d5(%rip), %r8      # 0xf27b2
movq %rdx, %rdi
callq 0xe6a0
xorl %eax, %eax
movl %eax, %edx
leaq 0xe86d7(%rip), %rsi     # 0xf27c7
xorl %ecx, %ecx
leaq 0xe86b9(%rip), %r8      # 0xf27b2
movq %rdx, %rdi
callq 0xe6a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/sam.c
// Function: test_bam_set1_validate_qname
static void test_bam_set1_validate_qname(void)
{
    int r;
    bam1_t *bam = NULL;
    bam = bam_init1();
    VERIFY(bam != NULL, "failed to initialize BAM struct.");

    // qname too long
    const char too_long[255] = { 'A' };
    r = bam_set1(bam, sizeof(too_long), too_long, BAM_FUNMAP, -1, 0, 0xff, 0, NULL, -1, 0, 0, 0, NULL, NULL, 0);
    VERIFY(r < 0, "call to bam_set1() should have failed.");
    VERIFY(errno == EINVAL, "errno should be set.");

cleanup:
    if (bam != NULL) bam_destroy1(bam);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq $0x0, -0x10(%rbp)
callq 0x37e90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbcc4
leaq 0xe7f0d(%rip), %rdi     # 0xf3bb7
leaq 0xe7139(%rip), %rsi     # 0xf2dea
leaq 0xe6e66(%rip), %rdx     # 0xf2b1e
movb $0x0, %al
callq 0x5b50
jmp 0xbdab
leaq -0x110(%rbp), %rdi
xorl %esi, %esi
movl $0xff, %edx
callq 0x4240
movb $0x41, -0x110(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x110(%rbp), %rdx
movl $0xff, %esi
movl $0x4, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r9d
movl $0xff, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x382b0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xbd81
leaq 0xe7e4d(%rip), %rdi     # 0xf3bb7
leaq 0xe7079(%rip), %rsi     # 0xf2dea
leaq 0xe708f(%rip), %rdx     # 0xf2e07
movb $0x0, %al
callq 0x5b50
jmp 0xbdab
callq 0x4050
cmpl $0x16, (%rax)
je 0xbda9
leaq 0xe7e25(%rip), %rdi     # 0xf3bb7
leaq 0xe7051(%rip), %rsi     # 0xf2dea
leaq 0xe708e(%rip), %rdx     # 0xf2e2e
movb $0x0, %al
callq 0x5b50
jmp 0xbdab
jmp 0xbdab
cmpq $0x0, -0x10(%rbp)
je 0xbdbb
movq -0x10(%rbp), %rdi
callq 0x380d0
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/sam.c
// Function: test_bam_set1_validate_seq
static void test_bam_set1_validate_seq(void)
{
    int r;
    bam1_t *bam = NULL;
    bam = bam_init1();
    VERIFY(bam != NULL, "failed to initialize BAM struct.");

    // seq too long
    const char *sequence = "C";
    r = bam_set1(bam, 0, NULL, BAM_FUNMAP, -1, 0, 0xff, 0, NULL, -1, 0, 0, (size_t)INT32_MAX + 1, sequence, NULL, 0);
    VERIFY(r < 0, "call to bam_set1() should have failed.");
    VERIFY(errno == EINVAL, "errno should be set.");

cleanup:
    if (bam != NULL) bam_destroy1(bam);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq $0x0, -0x10(%rbp)
callq 0x37e90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbe11
leaq 0xe7dc0(%rip), %rdi     # 0xf3bb7
leaq 0xe7045(%rip), %rsi     # 0xf2e43
leaq 0xe6d19(%rip), %rdx     # 0xf2b1e
movb $0x0, %al
callq 0x5b50
jmp 0xbee5
leaq 0xec073(%rip), %rax     # 0xf7e8b
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %r9d
movl $0x4, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0x80000000, %r10d      # imm = 0x80000000
movq %r9, %rsi
movq %r9, %rdx
movl $0xff, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x382b0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xbebb
leaq 0xe7d13(%rip), %rdi     # 0xf3bb7
leaq 0xe6f98(%rip), %rsi     # 0xf2e43
leaq 0xe6f55(%rip), %rdx     # 0xf2e07
movb $0x0, %al
callq 0x5b50
jmp 0xbee5
callq 0x4050
cmpl $0x16, (%rax)
je 0xbee3
leaq 0xe7ceb(%rip), %rdi     # 0xf3bb7
leaq 0xe6f70(%rip), %rsi     # 0xf2e43
leaq 0xe6f54(%rip), %rdx     # 0xf2e2e
movb $0x0, %al
callq 0x5b50
jmp 0xbee5
jmp 0xbee5
cmpq $0x0, -0x10(%rbp)
je 0xbef5
movq -0x10(%rbp), %rdi
callq 0x380d0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/sam.c
// Function: test_cigar_api
static void test_cigar_api(void)
{
    uint32_t *buf = NULL;
    char *cig = "*";
    char *end;
    size_t m = 0;
    int n;
    n = sam_parse_cigar(cig, &end, &buf, &m);
    VERIFY(n == 0 && m == 0 && (end-cig) == 1, "failed to parse undefined CIGAR");
    cig = "2M3X1I10M5D";
    n = sam_parse_cigar(cig, &end, &buf, &m);
    VERIFY(n == 5 && m > 0 && (end-cig) == 11, "failed to parse CIGAR string: 2M3X1I10M5D");
    n = sam_parse_cigar("722M15D187217376188323783284M67I", NULL, &buf, &m);
    VERIFY(n == -1, "failed to flag CIGAR string with long op length: 722M15D187217376188323783284M67I");
    n = sam_parse_cigar("53I722MD8X", NULL, &buf, &m);
    VERIFY(n == -1, "failed to flag CIGAR string with no op length: 53I722MD8X");

cleanup:
    free(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq $0x0, -0x8(%rbp)
leaq 0xeb0b3(%rip), %rax     # 0xf7c4a
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x408e0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xcbd9
cmpq $0x0, -0x20(%rbp)
jne 0xcbd9
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
je 0xcbfa
leaq 0xe6fd7(%rip), %rdi     # 0xf3bb7
leaq 0xe65a9(%rip), %rsi     # 0xf3190
leaq 0xe65b1(%rip), %rdx     # 0xf319f
movb $0x0, %al
callq 0x5b50
jmp 0xccdc
leaq 0xe65dc(%rip), %rax     # 0xf31dd
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x408e0
movl %eax, -0x24(%rbp)
cmpl $0x5, -0x24(%rbp)
jne 0xcc3b
cmpq $0x0, -0x20(%rbp)
jbe 0xcc3b
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0xb, %rax
je 0xcc5c
leaq 0xe6f75(%rip), %rdi     # 0xf3bb7
leaq 0xe6547(%rip), %rsi     # 0xf3190
leaq 0xe656f(%rip), %rdx     # 0xf31bf
movb $0x0, %al
callq 0x5b50
jmp 0xccdc
leaq 0xe65b7(%rip), %rdi     # 0xf321a
xorl %eax, %eax
movl %eax, %esi
leaq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x408e0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0xcc9b
leaq 0xe6f33(%rip), %rdi     # 0xf3bb7
leaq 0xe6505(%rip), %rsi     # 0xf3190
leaq 0xe6557(%rip), %rdx     # 0xf31e9
movb $0x0, %al
callq 0x5b50
jmp 0xccdc
leaq 0xe65c8(%rip), %rdi     # 0xf326a
xorl %eax, %eax
movl %eax, %esi
leaq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x408e0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0xccda
leaq 0xe6ef4(%rip), %rdi     # 0xf3bb7
leaq 0xe64c6(%rip), %rsi     # 0xf3190
leaq 0xe656a(%rip), %rdx     # 0xf323b
movb $0x0, %al
callq 0x5b50
jmp 0xccdc
jmp 0xccdc
movq -0x8(%rbp), %rdi
callq 0x45a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45c80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcd3a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x45d30
movq %rax, -0x20(%rbp)
jmp 0xcd17
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0xcd5a
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq 0xe4506(%rip), %rdi     # 0xf1259
movb $0x0, %al
callq 0x5b50
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x42, %edx
callq 0x5ac0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xced7
movq -0x28(%rbp), %rdi
callq 0x46d60
cmpl -0x14(%rbp), %eax
je 0xcdfd
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x46d60
movq -0x38(%rbp), %rsi
movl %eax, %edx
movl -0x14(%rbp), %ecx
leaq 0xe4485(%rip), %rdi     # 0xf127b
movb $0x0, %al
callq 0x5b50
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xced5
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x46db0
movq -0x20(%rbp), %rcx
movl -0x2c(%rbp), %edx
cmpq (%rcx,%rdx,8), %rax
je 0xce66
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x46db0
movq -0x48(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %edi
movq (%rax,%rdi,8), %r8
leaq 0xe4454(%rip), %rdi     # 0xf12b3
movb $0x0, %al
callq 0x5b50
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x46e10
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
cvtsi2sdq (%rax,%rcx,8), %xmm1
ucomisd %xmm1, %xmm0
jne 0xce89
jp 0xce89
jmp 0xcec5
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x46e10
movq -0x58(%rbp), %rsi
movl -0x4c(%rbp), %edx
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
cvtsi2sdq (%rax,%rcx,8), %xmm1
leaq 0xe443d(%rip), %rdi     # 0xf12fb
movb $0x2, %al
callq 0x5b50
jmp 0xcec7
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xce04
jmp 0xced7
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
testb %al, %al
je 0xe49b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0xe51e
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0xe53b
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xe5f1
leaq -0x30(%rbp), %rax
movq %rax, -0x118(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x10c(%rbp)
cmpl $0x28, %eax
ja 0xe58e
movq -0x118(%rbp), %rcx
movl -0x10c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x120(%rbp)
jmp 0xe5ab
movq -0x118(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x120(%rbp)
movq -0x120(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18e40
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
je 0xe5ec
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x38(%rbp), %ecx
movl -0x34(%rbp), %r8d
leaq 0xe3cba(%rip), %rdi     # 0xf229f
movb $0x0, %al
callq 0x5b50
jmp 0xe4e3
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xe683
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x18f90
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0xe676
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x38(%rbp), %r8
leaq 0xe408b(%rip), %rdi     # 0xf26f1
movb $0x0, %al
callq 0x5b50
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe68a
jmp 0xe678
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xe61e
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/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe6e2
movq 0x102917(%rip), %rax    # 0x110fe0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xe40f8(%rip), %rsi     # 0xf27d3
movb $0x0, %al
callq 0x46d0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x2b1f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xe71d
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %r8
leaq 0xe40db(%rip), %rdi     # 0xf27f1
movb $0x0, %al
callq 0x5b50
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x38(%rbp), %rsi
callq 0x2b1f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xe758
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %r8
leaq 0xe40df(%rip), %rdi     # 0xf2830
movb $0x0, %al
callq 0x5b50
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xe78e
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq 0xe40e7(%rip), %rdi     # 0xf286e
movb $0x0, %al
callq 0x5b50
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch6/library_subset.c
// Function: main
int main() {

  lua_State *L = luaL_newstate();
  int set_global = 1;

  // Choose how many libraries to work with.
  Mode mode = mode_all_libs;  // Change this value to explore.
  switch (mode) {

    case mode_all_libs:
      luaL_openlibs(L);
      break;

    case mode_some_libs:
      luaL_requiref(L, "package", luaopen_package, set_global);
      luaL_requiref(L, "string", luaopen_string, set_global);
      luaL_requiref(L, "table", luaopen_table, set_global);
      luaL_requiref(L, "math", luaopen_math, set_global);
      // Fall through to also include the next case.

    case mode_base_only:
      luaL_requiref(L, "_G", luaopen_base, set_global);
      break;
  }

  luaL_dofile(L, "run_bash.lua");

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
callq 0x213b0
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x5619
jmp 0x5602
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x5627
jmp 0x560c
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x568f
jmp 0x56a9
movq -0x10(%rbp), %rdi
callq 0x29d90
jmp 0x56a9
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq 0x2d9cf(%rip), %rsi     # 0x33004
leaq 0x23564(%rip), %rdx     # 0x28ba0
callq 0x211f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq 0x3000d(%rip), %rsi     # 0x3565c
leaq 0x1e12a(%rip), %rdx     # 0x23780
callq 0x211f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq 0x3008c(%rip), %rsi     # 0x356f5
leaq 0x225c0(%rip), %rdx     # 0x27c30
callq 0x211f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq 0x2d989(%rip), %rsi     # 0x3300c
leaq 0x1d436(%rip), %rdx     # 0x22ac0
callq 0x211f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq 0x2d974(%rip), %rsi     # 0x33011
leaq 0x1c0cc(%rip), %rdx     # 0x21770
callq 0x211f0
movq -0x10(%rbp), %rdi
leaq 0x2d960(%rip), %rsi     # 0x33014
xorl %eax, %eax
movl %eax, %edx
callq 0x20880
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
jne 0x56ec
movq -0x10(%rbp), %rdi
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %esi
movq %r9, %r8
callq 0x7e10
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x10(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x14db
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x1480
movl -0xc(%rbp), %edi
addl $0x1, %edi
movl -0x8(%rbp), %esi
callq 0x1480
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x1290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
callq 0x10a0
movl %eax, %edi
callq 0x1080
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x16fb
callq 0x1110
movl $0x64, %ecx
cltd
idivl %ecx
movslq -0xc(%rbp), %rcx
leaq 0x29e3(%rip), %rax      # 0x40d0
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x16cf
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
callq 0x16b0
leaq 0x2999(%rip), %rdi      # 0x40c4
leaq -0x4c2(%rip), %rsi      # 0x1270
callq 0x1070
movl $0x0, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jge 0x1771
movslq -0x8(%rbp), %rax
leaq -0x30(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x26e(%rip), %rdx      # 0x14f0
movq %rcx, %rsi
callq 0x10c0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x173e
movl $0x0, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jge 0x179b
movslq -0x8(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1100
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1778
xorl %edi, %edi
movl $0x4, %esi
movl $0x9, %edx
callq 0x1290
movl $0xa, %edi
movl $0xe, %esi
movl $0x13, %edx
callq 0x1290
xorl %edi, %edi
movl $0x9, %esi
movl $0x13, %edx
callq 0x1290
movl $0x0, -0x8(%rbp)
cmpl $0x14, -0x8(%rbp)
jge 0x1805
movslq -0x8(%rbp), %rcx
leaq 0x28e7(%rip), %rax      # 0x40d0
movl (%rax,%rcx,4), %esi
leaq 0x8a5(%rip), %rdi       # 0x2098
movb $0x0, %al
callq 0x1060
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x17d8
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: usage
static void
usage(FILE *stream, int status)
{
	(void) fprintf(stream, _("%s: usage is %s \
[ --version ] [ --help ] [ -v ] [ -l localtime ] [ -p posixrules ] \\\n\
\t[ -d directory ] [ -L leapseconds ] [ -y yearistype ] [ filename ... ]\n\
\n\
Report bugs to tz@elsie.nci.nih.gov.\n"),
		       progname, progname);
	exit(status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq 0xf836(%rip), %rdx      # 0x121b0
movq 0xf82f(%rip), %rcx      # 0x121b0
leaq 0xb981(%rip), %rsi      # 0xe309
movb $0x0, %al
callq 0x2180
movl -0xc(%rbp), %edi
callq 0x2270
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: setboundaries
static void
setboundaries(void)
{
	register int	i;

	min_time = -1;
	for (i = 0; i < TIME_T_BITS_IN_FILE - 1; ++i)
		min_time *= 2;
	max_time = -(min_time + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $-0x1, 0xf879(%rip) # 0x12228
movl $0x0, -0x4(%rbp)
cmpl $0x3f, -0x4(%rbp)
jge 0x29d8
movq 0xf865(%rip), %rax      # 0x12228
shlq %rax
movq %rax, 0xf85b(%rip)      # 0x12228
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x29b6
movq 0xf849(%rip), %rcx      # 0x12228
addq $0x1, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, 0xf841(%rip)      # 0x12230
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: adjleap
static void
adjleap(void)
{
	register int	i;
	register long	last = 0;

	/*
	** propagate leap seconds forward
	*/
	for (i = 0; i < leapcnt; ++i) {
		trans[i] = tadd(trans[i], last);
		last = corr[i] += last;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xf5e4(%rip), %eax      # 0x123a4
jge 0x2e19
movslq -0x4(%rbp), %rcx
leaq 0xf5e3(%rip), %rax      # 0x123b0
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x6440
movq %rax, %rdx
movslq -0x4(%rbp), %rcx
leaq 0xf5c8(%rip), %rax      # 0x123b0
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rdx
leaq 0xf745(%rip), %rcx      # 0x12540
addq (%rcx,%rdx,8), %rax
leaq 0xf73a(%rip), %rcx      # 0x12540
movq %rax, (%rcx,%rdx,8)
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2db7
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xa3ba(%rip), %rdi      # 0xe3cd
callq 0xd140
movq %rax, %rdi
callq 0x40b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xd090
movq %rax, %rdi
callq 0x40b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4110
movq -0x10(%rbp), %rdi
callq 0xd160
movl 0xe18f(%rip), %eax      # 0x121e4
addl $-0x1, %eax
movl %eax, 0xe186(%rip)      # 0x121e4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: eats
static void
eats(name, num, rname, rnum)
const char * const	name;
const int		num;
const char * const	rname;
const int		rnum;
{
	filename = name;
	linenum = num;
	rfilename = rname;
	rlinenum = rnum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0xe17b(%rip)      # 0x12208
movl -0xc(%rbp), %eax
movl %eax, 0xe17a(%rip)      # 0x12210
movq -0x18(%rbp), %rax
movq %rax, 0xe177(%rip)      # 0x12218
movl -0x1c(%rbp), %eax
movl %eax, 0xe176(%rip)      # 0x12220
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xded5(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xe0db(%rip), %rdx      # 0x12208
movl 0xe0dd(%rip), %ecx      # 0x12210
movq -0x8(%rbp), %r8
leaq 0xa2b3(%rip), %rsi      # 0xe3f1
movb $0x0, %al
callq 0x2180
cmpq $0x0, 0xe0cb(%rip)      # 0x12218
je 0x4174
movq 0xdea2(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xe0b8(%rip), %rdx      # 0x12218
movl 0xe0ba(%rip), %ecx      # 0x12220
leaq 0xa296(%rip), %rsi      # 0xe403
movb $0x0, %al
callq 0x2180
movq 0xde7d(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0xa246(%rip), %rsi      # 0xe3cb
movb $0x0, %al
callq 0x2180
movl 0xe052(%rip), %eax      # 0x121e4
addl $0x1, %eax
movl %eax, 0xe049(%rip)      # 0x121e4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd140
movq %rax, %rdi
callq 0x40b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa28d(%rip), %rsi      # 0xe469
callq 0xd090
movq %rax, %rdi
callq 0x40b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x2210
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd160
cmpl $0x0, -0x14(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x423f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x424b
movl $0x0, -0x4(%rbp)
jmp 0x432d
movq -0x10(%rbp), %rdi
callq 0xd140
movq %rax, %rdi
callq 0x40b0
movq %rax, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movl $0x2f, %esi
callq 0x20f0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x431d
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x41b0
cmpl $0x0, %eax
jne 0x4311
movq -0x18(%rbp), %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x2090
cmpl $0x0, %eax
je 0x430f
callq 0x2050
movl (%rax), %edi
callq 0x2290
movq %rax, -0x28(%rbp)
callq 0x2050
cmpl $0x11, (%rax)
jne 0x42d4
movq -0x18(%rbp), %rdi
callq 0x41b0
cmpl $0x0, %eax
jne 0x430d
movq 0xdd1d(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xdecb(%rip), %rdx      # 0x121b0
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0xa178(%rip), %rsi      # 0xe46c
movb $0x0, %al
callq 0x2180
movq -0x18(%rbp), %rdi
callq 0xd160
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x432d
jmp 0x430f
jmp 0x4311
movq -0x20(%rbp), %rax
movb $0x2f, (%rax)
jmp 0x4264
movq -0x18(%rbp), %rdi
callq 0xd160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: oadd
static long
oadd(t1, t2)
const long	t1;
const long	t2;
{
	register long	t;

	t = t1 + t2;
	if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
		error(_("time overflow"));
		exit(EXIT_FAILURE);
	}
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jle 0x462d
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jle 0x463e
cmpq $0x0, -0x10(%rbp)
jge 0x4654
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jl 0x4654
leaq 0x9ea0(%rip), %rdi      # 0xe4e5
callq 0x4110
movl $0x1, %edi
callq 0x2270
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: eitol
static long
eitol(i)
const int	i;
{
	long	l;

	l = i;
	if ((i < 0 && l >= 0) || (i == 0 && l != 0) || (i > 0 && l <= 0)) {
		(void) fprintf(stderr,
			_("%s: %d did not sign extend correctly\n"),
			progname, i);
		exit(EXIT_FAILURE);
	}
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x4680
cmpq $0x0, -0x10(%rbp)
jge 0x469a
cmpl $0x0, -0x4(%rbp)
jne 0x468d
cmpq $0x0, -0x10(%rbp)
jne 0x469a
cmpl $0x0, -0x4(%rbp)
jle 0x46c6
cmpq $0x0, -0x10(%rbp)
jg 0x46c6
movq 0xd957(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xdb05(%rip), %rdx      # 0x121b0
movl -0x4(%rbp), %ecx
leaq 0x9ea9(%rip), %rsi      # 0xe55e
movb $0x0, %al
callq 0x2180
movl $0x1, %edi
callq 0x2270
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: inzcont
static int
inzcont(fields, nfields)
register char ** const	fields;
const int		nfields;
{
	if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS) {
		error(_("wrong number of fields on Zone continuation line"));
		return FALSE;
	}
	return inzsub(fields, nfields, TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jl 0x492b
cmpl $0x7, -0x14(%rbp)
jle 0x4940
leaq 0x9d5e(%rip), %rdi      # 0xe690
callq 0x4110
movl $0x0, -0x4(%rbp)
jmp 0x4954
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x5520
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: inrule
static void
inrule(fields, nfields)
register char ** const	fields;
const int		nfields;
{
	static struct rule	r;

	if (nfields != RULE_FIELDS) {
		error(_("wrong number of fields on Rule line"));
		return;
	}
	if (*fields[RF_NAME] == '\0') {
		error(_("nameless rule"));
		return;
	}
	r.r_filename = filename;
	r.r_linenum = linenum;
	r.r_stdoff = gethms(fields[RF_STDOFF], _("invalid saved time"), TRUE);
	rulesub(&r, fields[RF_LOYEAR], fields[RF_HIYEAR], fields[RF_COMMAND],
		fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
	r.r_name = ecpyalloc(fields[RF_NAME]);
	r.r_abbrvar = ecpyalloc(fields[RF_ABBRVAR]);
	if (max_abbrvar_len < strlen(r.r_abbrvar))
		max_abbrvar_len = strlen(r.r_abbrvar);
	rules = (struct rule *) (void *) erealloc((char *) rules,
		(int) ((nrules + 1) * sizeof *rules));
	rules[nrules++] = r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
je 0x4a66
leaq 0x9edc(%rip), %rdi      # 0xe938
callq 0x4110
jmp 0x4bcc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4a87
leaq 0x9edf(%rip), %rdi      # 0xe95c
callq 0x4110
jmp 0x4bcc
movq 0xd77a(%rip), %rax      # 0x12208
movq %rax, 0xd883(%rip)      # 0x12318
movl 0xd775(%rip), %eax      # 0x12210
movl %eax, 0xd87f(%rip)      # 0x12320
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0x9eba(%rip), %rsi      # 0xe96a
movl $0x1, %edx
callq 0x4370
movq %rax, 0xd8a7(%rip)      # 0x12368
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r9
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
leaq 0xd820(%rip), %rdi      # 0x12318
movq %rax, (%rsp)
callq 0x5950
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd140
movq %rax, %rdi
callq 0x40b0
movq %rax, 0xd80b(%rip)      # 0x12328
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0xd140
movq %rax, %rdi
callq 0x40b0
movq %rax, 0xd837(%rip)      # 0x12370
movslq 0xd848(%rip), %rax      # 0x12388
movq %rax, -0x18(%rbp)
movq 0xd825(%rip), %rdi      # 0x12370
callq 0x20d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x4b6e
movq 0xd80d(%rip), %rdi      # 0x12370
callq 0x20d0
movl %eax, 0xd81a(%rip)      # 0x12388
movq 0xd6cb(%rip), %rdi      # 0x12240
movl 0xd6bd(%rip), %eax      # 0x12238
addl $0x1, %eax
cltq
imulq $0x70, %rax, %rax
movl %eax, %esi
callq 0xd030
movq %rax, %rdi
callq 0x40b0
movq %rax, 0xd6a6(%rip)      # 0x12240
movq 0xd69f(%rip), %rdi      # 0x12240
movl 0xd691(%rip), %eax      # 0x12238
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xd686(%rip)      # 0x12238
cltq
imulq $0x70, %rax, %rax
addq %rax, %rdi
leaq 0xd756(%rip), %rsi      # 0x12318
movl $0x70, %edx
callq 0x21a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: inlink
static void
inlink(fields, nfields)
register char ** const	fields;
const int		nfields;
{
	struct link	l;

	if (nfields != LINK_FIELDS) {
		error(_("wrong number of fields on Link line"));
		return;
	}
	if (*fields[LF_FROM] == '\0') {
		error(_("blank FROM field on Link line"));
		return;
	}
	if (*fields[LF_TO] == '\0') {
		error(_("blank TO field on Link line"));
		return;
	}
	l.l_filename = filename;
	l.l_linenum = linenum;
	l.l_from = ecpyalloc(fields[LF_FROM]);
	l.l_to = ecpyalloc(fields[LF_TO]);
	links = (struct link *) (void *) erealloc((char *) links,
		(int) ((nlinks + 1) * sizeof *links));
	links[nlinks++] = l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
je 0x4e86
leaq 0x9bb9(%rip), %rdi      # 0xea35
callq 0x4110
jmp 0x4f7b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4ea7
leaq 0x9bbc(%rip), %rdi      # 0xea59
callq 0x4110
jmp 0x4f7b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4ec8
leaq 0x9bb9(%rip), %rdi      # 0xea77
callq 0x4110
jmp 0x4f7b
movq 0xd339(%rip), %rax      # 0x12208
movq %rax, -0x30(%rbp)
movl 0xd337(%rip), %eax      # 0x12210
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd140
movq %rax, %rdi
callq 0x40b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xd140
movq %rax, %rdi
callq 0x40b0
movq %rax, -0x18(%rbp)
movq 0xd2eb(%rip), %rdi      # 0x12200
movl 0xd2dd(%rip), %eax      # 0x121f8
addl $0x1, %eax
cltq
shlq $0x5, %rax
movl %eax, %esi
callq 0xd030
movq %rax, %rdi
callq 0x40b0
movq %rax, 0xd2c6(%rip)      # 0x12200
movq 0xd2bf(%rip), %rax      # 0x12200
movl 0xd2b1(%rip), %ecx      # 0x121f8
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xd2a6(%rip)      # 0x121f8
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: tadd
static zic_t
tadd(t1, t2)
const zic_t	t1;
const long	t2;
{
	register zic_t	t;

	if (t1 == max_time && t2 > 0)
		return max_time;
	if (t1 == min_time && t2 < 0)
		return min_time;
	t = t1 + t2;
	if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
		error(_("time overflow"));
		exit(EXIT_FAILURE);
	}
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq 0xbdd5(%rip), %rax      # 0x12230
jne 0x6471
cmpq $0x0, -0x18(%rbp)
jle 0x6471
movq 0xbdc5(%rip), %rax      # 0x12230
movq %rax, -0x8(%rbp)
jmp 0x64de
movq -0x10(%rbp), %rax
cmpq 0xbdac(%rip), %rax      # 0x12228
jne 0x6492
cmpq $0x0, -0x18(%rbp)
jge 0x6492
movq 0xbd9c(%rip), %rax      # 0x12228
movq %rax, -0x8(%rbp)
jmp 0x64de
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x64af
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jle 0x64c0
cmpq $0x0, -0x18(%rbp)
jge 0x64d6
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jl 0x64d6
leaq 0x801e(%rip), %rdi      # 0xe4e5
callq 0x4110
movl $0x1, %edi
callq 0x2270
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: ciequal
static int
ciequal(ap, bp)		/* case-insensitive equality */
register const char *	ap;
register const char *	bp;
{
	while (lowerit(*ap) == lowerit(*bp++))
		if (*ap++ == '\0')
			return TRUE;
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x63e0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %edi
callq 0x63e0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jne 0x6551
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x654f
movl $0x1, -0x4(%rbp)
jmp 0x6558
jmp 0x6500
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: itsabbr
static int
itsabbr(abbr, word)
register const char *	abbr;
register const char *	word;
{
	if (lowerit(*abbr) != lowerit(*word))
		return FALSE;
	++word;
	while (*++abbr != '\0')
		do {
			if (*word == '\0')
				return FALSE;
		} while (lowerit(*word++) != lowerit(*abbr));
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x63e0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x63e0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
je 0x65ad
movl $0x0, -0x4(%rbp)
jmp 0x6622
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x661b
jmp 0x65d3
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x65e8
movl $0x0, -0x4(%rbp)
jmp 0x6622
jmp 0x65ea
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %edi
callq 0x63e0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x63e0
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jne 0x65d3
jmp 0x65b9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zic.c
// Function: updateminmax
static void
updateminmax(x)
const int	x;
{
	if (min_year > x)
		min_year = x;
	if (max_year < x)
		max_year = x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl 0xbef7(%rip), %eax      # 0x12714
cmpl -0x4(%rbp), %eax
jle 0x682b
movl -0x4(%rbp), %eax
movl %eax, 0xbee9(%rip)      # 0x12714
movl 0xbedf(%rip), %eax      # 0x12710
cmpl -0x4(%rbp), %eax
jge 0x683f
movl -0x4(%rbp), %eax
movl %eax, 0xbed1(%rip)      # 0x12710
popq %rbp
retq
nopw %cs:(%rax,%rax)