LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: sp_tree_remove_all
void sp_tree_remove_all(sp_tree *tree, void (* free_data) (void *)) {

    sp_node *root;
    sp_node *left;
    sp_node *right;

    // Sanity check:
    assert(tree != NULL);

    // Initialize:
    root = tree->root;
    tree->root = NULL;

    // While the tree is not empty:
    while (root != NULL) {

        // Unravel the tree: Rotate right "root" & "left"
        if (root->left != NULL) {
            left        = root->left;
            right       = left->right;
            left->right = root;
            root->left  = right;
            root        = left;

        // Erase the current "root" node:
        } else {
            right = root->right;
            if (free_data != NULL) { free_data(root->data); }
            free(root);
            root = right;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbad6
movq %rsi, %rbx
movq (%rdi), %r14
andq $0x0, (%rdi)
testq %r14, %r14
je 0xbad0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xbab5
movq 0x10(%rax), %rcx
movq %r14, 0x10(%rax)
movq %rcx, 0x8(%r14)
movq %rax, %r14
jmp 0xba96
movq 0x10(%r14), %r15
testq %rbx, %rbx
je 0xbac3
movq (%r14), %rdi
callq *%rbx
movq %r14, %rdi
callq 0x1120
movq %r15, %r14
jmp 0xba96
popq %rbx
popq %r14
popq %r15
retq
leaq 0x17a6(%rip), %rdi      # 0xd283
leaq 0x1729(%rip), %rsi      # 0xd20d
leaq 0x2295(%rip), %rcx      # 0xdd80
movl $0x1417, %edx           # imm = 0x1417
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: sp_tree_intersection
sp_tree *sp_tree_intersection(sp_tree *tree_1, sp_tree *tree_2) {

    sp_tree *tree;
    void    *data_1;
    void    *data_2;
    int      comp;

    // Sanity check:
    assert(tree_1 != NULL);
    assert(tree_2 != NULL);

    // Special case: Both trees are the same
    if (tree_1 == tree_2) { return sp_tree_copy(tree_1); }

    // Create a new tree:
    tree = new_sp_tree(tree_1->comp);
    if (tree == NULL) { return NULL; }

    // Special case: Some of them is empty
    if (sp_tree_is_empty(tree_1) == YES) { return tree; }
    if (sp_tree_is_empty(tree_2) == YES) { return tree; }
    
    // Get the smallest element of each tree:
    data_1 = sp_tree_min(tree_1);
    data_2 = sp_tree_min(tree_2);

    // Until we have exhausted at least one of the trees:
    while (data_1 != NULL && data_2 != NULL) {

        // compare both nodes:
        comp = (tree->comp)(data_1, data_2);

        if (comp < 0) {

            // advance data_1:
            data_1 = sp_tree_next(tree_1, data_1);

        } else if (comp > 0) {

            // advance data_2:
            data_2 = sp_tree_next(tree_2, data_2);

        } else {

            // insert data_1 in tree:
            sp_tree_insert_max(tree, data_1);

            // advance data_1:
            data_1 = sp_tree_next(tree_1, data_1);

            // advance data_2:
            data_2 = sp_tree_next(tree_2, data_2);

        }
    }

    // Return the resulting tree:
    return tree;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xbd23
movq %rsi, %r14
testq %rsi, %rsi
je 0xbd42
movq %rdi, %rbx
cmpq %r14, %rdi
je 0xbd02
movq 0x8(%rbx), %rdi
callq 0xb14a
testq %rax, %rax
je 0xbd13
movq %rax, %r15
cmpq $0x0, (%rbx)
je 0xbd16
cmpq $0x0, (%r14)
je 0xbd16
movq %rbx, %rdi
callq 0xb21f
movq %rax, %r12
movq %r14, %rdi
callq 0xb21f
movq %rax, %r13
testq %r12, %r12
je 0xbd16
testq %r13, %r13
je 0xbd16
movq %r12, %rdi
movq %r13, %rsi
callq *0x8(%r15)
testl %eax, %eax
jns 0xbcd8
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb322
movq %rax, %r12
jmp 0xbcb0
je 0xbce7
movq %r14, %rdi
movq %r13, %rsi
callq 0xb322
jmp 0xbcad
movq %r15, %rdi
movq %r12, %rsi
callq 0xb261
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb322
movq %rax, %r12
jmp 0xbcda
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb1b6
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x17ec(%rip), %rdi      # 0xd516
leaq 0x14dc(%rip), %rsi      # 0xd20d
leaq 0x20aa(%rip), %rcx      # 0xdde2
movl $0x149d, %edx           # imm = 0x149D
callq 0x1080
leaq 0x1815(%rip), %rdi      # 0xd55e
leaq 0x14bd(%rip), %rsi      # 0xd20d
leaq 0x208b(%rip), %rcx      # 0xdde2
movl $0x149e, %edx           # imm = 0x149E
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: is_sp_tree
int is_sp_tree(const sp_tree *tree) {

    // Basic Sanity Checks:
    if (tree == NULL) {
        fprintf(stderr, "ERROR: NULL pointer to sp_tree\n");
        return NO;
    }
    if (tree->comp == NULL) {
        fprintf(stderr, "ERROR: NULL comparing function in sp_tree\n");
        return NO;
    }

    // Trivial Case: empty tree
    if (tree->root == NULL) { return YES; }

    // General Case:
    return is_sp_subtree(tree, tree->root, NULL, NULL);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xbfdb
cmpq $0x0, 0x8(%rdi)
je 0xbff0
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xbfd6
xorl %edx, %edx
xorl %ecx, %ecx
popq %rax
jmp 0xc010
pushq $0x1
popq %rax
jmp 0xc00e
movq 0x5016(%rip), %rax      # 0x10ff8
movq (%rax), %rcx
leaq 0x1e86(%rip), %rdi      # 0xde72
pushq $0x1f
jmp 0xc003
movq 0x5001(%rip), %rax      # 0x10ff8
movq (%rax), %rcx
leaq 0x1e91(%rip), %rdi      # 0xde92
pushq $0x2a
popq %rsi
pushq $0x1
popq %rdx
callq 0x1100
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: is_sp_subtree
static int is_sp_subtree(const sp_tree *tree, const sp_node *node,
                         const void *min, const void *max) {

    // Make sure that node is (strictly) between specified limits:
    if (min != NULL && (tree->comp)(min, node->data) >= 0) {
        fprintf(stderr,"ERROR: Symmetric order not satisfied in sp_tree\n");
        return NO;
    }
    if (max != NULL && (tree->comp)(node->data, max) >= 0) {
        fprintf(stderr,"ERROR: Symmetric order not satisfied in sp_tree\n");
        return NO;
    }

    // Check recursively the left subtree of node:
    if (node->left != NULL) {
        if (is_sp_subtree(tree, node->left, min, node->data) == NO) {
            return NO;
        }
    }

    // Check recursively the right subtree of node:
    if (node->right != NULL) {
        if (is_sp_subtree(tree, node->right, node->data, max) == NO) {
            return NO;
        }
    }

    // All test are fine:
    return YES;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0xc037
movq (%r15), %rsi
movq %r12, %rdi
callq *0x8(%r14)
testl %eax, %eax
jns 0xc085
testq %rbx, %rbx
je 0xc04a
movq (%r15), %rdi
movq %rbx, %rsi
callq *0x8(%r14)
testl %eax, %eax
jns 0xc085
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0xc065
movq (%r15), %rcx
movq %r14, %rdi
movq %r12, %rdx
callq 0xc010
testl %eax, %eax
je 0xc0a1
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0xc080
movq (%r15), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0xc010
testl %eax, %eax
je 0xc0a1
pushq $0x1
popq %rax
jmp 0xc0a3
movq 0x4f6c(%rip), %rax      # 0x10ff8
movq (%rax), %rcx
leaq 0x1fce(%rip), %rdi      # 0xe064
pushq $0x30
popq %rsi
pushq $0x1
popq %rdx
callq 0x1100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: print_sp_tree
void print_sp_tree(const sp_tree *tree, void (* print_node) (const void *)) {

    // Avoid the trivial cases:
    if (tree != NULL && tree->root != NULL) {

        // Print right subtree recursively:
        if (tree->root->right != NULL) {
            print_sp_subtree(tree->root->right, YES, "     ", print_node);
        }

        // Print current node:
        fprintf(stdout, "----");
        if (print_node == NULL) { fprintf(stdout, "(#)"); }
        else { print_node(tree->root->data); }
        fprintf(stdout, "\n");

        // Print left subtree recursively:
        if (tree->root->left != NULL) {
            print_sp_subtree(tree->root->left, NO, "     ", print_node);
        }
    }

    // Empty the "stdout" buffer:
    fflush(stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xc152
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0xc152
movq %rsi, %rbx
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xc0ea
leaq 0x1e7a(%rip), %rdx      # 0xdf59
pushq $0x1
popq %rsi
movq %rbx, %rcx
callq 0xc166
movq 0x4ee7(%rip), %r15      # 0x10fd8
movq (%r15), %rcx
leaq 0x1e6e(%rip), %rdi      # 0xdf69
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x1100
testq %rbx, %rbx
je 0xc115
movq (%r14), %rax
movq (%rax), %rdi
callq *%rbx
jmp 0xc12a
movq (%r15), %rcx
leaq 0x15b8(%rip), %rdi      # 0xd6d7
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x1100
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1090
movq (%r14), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0xc152
leaq 0x1e11(%rip), %rdx      # 0xdf59
xorl %esi, %esi
movq %rbx, %rcx
callq 0xc166
movq 0x4e7f(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10e0
// File: /workspace/github_c_makefile_star2_O2/CarlosLunaMota[P]BinaryTrees/BinaryTrees.c
// Function: print_sp_subtree
static void print_sp_subtree(const sp_node *node, const int is_right,
                             char *indent, void (* print_node) (const void *)) {

    // Allocate memory:
    char *new_indent = (char *) malloc((6+strlen(indent)*sizeof(char)));
    assert(new_indent != NULL);

    // Print right subtree recursively:
    if (node->right != NULL) {
        if (is_right == YES) { sprintf(new_indent, "%s%s", indent, "      "); }
        else                 { sprintf(new_indent, "%s%s", indent, "|     "); }
        print_sp_subtree(node->right, YES, new_indent, print_node);
    }

    // Print current node:
    if (is_right) { fprintf(stdout, "%s,----",indent); }
    else          { fprintf(stdout, "%s`----",indent); }
    if (print_node == NULL)  { fprintf(stdout, "(#)"); }
    else                     { print_node(node->data); }
    printf("\n");

    // Print left subtree recursively:
    if (node->left != NULL) {
        if (is_right == YES) { sprintf(new_indent, "%s%s", indent, "|     "); }
        else                 { sprintf(new_indent, "%s%s", indent, "      "); }
        print_sp_subtree(node->left, NO, new_indent, print_node);
    }

    // Free memory:
    free(new_indent);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
callq 0x1060
leaq 0x6(%rax), %rdi
callq 0x10d0
testq %rax, %rax
je 0xc285
movq %rax, %r15
cmpq $0x0, 0x10(%r14)
je 0xc1db
cmpl $0x1, %ebp
leaq 0x1dae(%rip), %rax      # 0xdf58
leaq 0x1dae(%rip), %rcx      # 0xdf5f
cmoveq %rax, %rcx
leaq 0x1d97(%rip), %rsi      # 0xdf53
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x10f0
movq 0x10(%r14), %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xc166
testl %ebp, %ebp
movq 0x4df4(%rip), %r13      # 0x10fd8
movq (%r13), %rdi
leaq 0x1d7f(%rip), %rax      # 0xdf6e
leaq 0x1d70(%rip), %rsi      # 0xdf66
cmoveq %rax, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x10b0
testq %rbx, %rbx
je 0xc210
movq (%r14), %rdi
callq *%rbx
jmp 0xc226
movq (%r13), %rcx
leaq 0x14bc(%rip), %rdi      # 0xd6d7
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x1100
pushq $0xa
popq %rdi
callq 0x1030
cmpq $0x0, 0x8(%r14)
je 0xc26f
cmpl $0x1, %ebp
leaq 0x1d20(%rip), %rax      # 0xdf5f
leaq 0x1d12(%rip), %rcx      # 0xdf58
cmoveq %rax, %rcx
leaq 0x1d02(%rip), %rsi      # 0xdf53
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x10f0
movq 0x8(%r14), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xc166
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1120
leaq 0x1c62(%rip), %rdi      # 0xdeee
leaq 0xf7a(%rip), %rsi       # 0xd20d
leaq 0x1dfb(%rip), %rcx      # 0xe095
movl $0x15c3, %edx           # imm = 0x15C3
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/pingpong.c
// Function: locked_loop
inline int unlocked_xchg(atomic_t *p, atomic_t old, atomic_t new) {
  if (*(volatile atomic_t *)p == old) {
    *(volatile atomic_t *)p = new;
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x401ef9
movl 0x80(%rbx), %ecx
movl 0x84(%rbx), %edx
xorl %edi, %edi
movq 0xe8296(%rip), %rsi     # 0x4ea008
cmpl $0x0, 0xe8287(%rip)     # 0x4ea000
jne 0x401dcb
movl %ecx, %eax
lock
cmpxchgl %edx, (%rsi)
jne 0x401db9
movq 0xe7a7e(%rip), %rax     # 0x4e9808
xorl %r8d, %r8d
cmpq 0xe7a6c(%rip), %r8      # 0x4e9800
jae 0x401d9f
incq (%rax,%r8,8)
incq %r8
jmp 0x401d8d
incl %edi
movl %edi, %eax
xorl $0x2710, %eax           # imm = 0x2710
orl %ecx, %eax
jne 0x401db9
lock
addl $0x4e20, 0xe7e49(%rip)  # imm = 0x4E20
xorl %edi, %edi
xorl %eax, %eax
cmpq 0xe534e(%rip), %rax     # 0x4e7110
jae 0x401d72
pause
incq %rax
jmp 0x401dbb
xorl %edi, %edi
callq 0x41e3e0
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/pingpong.c
// Function: xadd_loop
static void *xadd_loop(void *data) {
  thread_args_t *args = (thread_args_t *)data;

  common_setup(args);
  uint64_t *xadder = (uint64_t *)pingpong_mutex;
  atomic_t me = args->me;
  uint64_t add_amt = (me == 0) ? 1 : (1ull << 32);
  uint32_t last_lo = 0;
  atomic_t nr = 0;

  while (1) {
    if (stop_loops) {
      pthread_exit(0);
    }

    uint64_t swap = __sync_fetch_and_add(xadder, add_amt);
    if (me == 1 && last_lo != (uint32_t)swap) {
      last_lo = swap;
      ++nr;
      if (nr == 10000) {
        __sync_fetch_and_add(&nr_pingpongs.x, 2 * nr);
        nr = 0;
      }
    }
    for (size_t i = 0; i < nr_relax; ++i) {
      cpu_relax();
    }
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x401ef9
movq 0xe81a7(%rip), %rax     # 0x4ea008
movl 0x80(%rbx), %ecx
testl %ecx, %ecx
pushq $0x1
popq %rsi
movabsq $0x100000000, %rdx      # imm = 0x100000000
cmoveq %rsi, %rdx
xorl %esi, %esi
xorl %r8d, %r8d
cmpl $0x0, 0xe817a(%rip)     # 0x4ea000
jne 0x401ece
movq %rdx, %rdi
lock
xaddq %rdi, (%rax)
cmpl $0x1, %ecx
jne 0x401e9a
cmpl %edi, %r8d
jne 0x401eb5
movl %r8d, %edi
xorl %r8d, %r8d
cmpq 0xe5269(%rip), %r8      # 0x4e7110
jae 0x401eb0
pause
incq %r8
jmp 0x401ea0
movl %edi, %r8d
jmp 0x401e7f
incl %esi
cmpl $0x2710, %esi           # imm = 0x2710
jne 0x401e9d
lock
addl $0x4e20, 0xe7d36(%rip)  # imm = 0x4E20
xorl %esi, %esi
jmp 0x401e9d
xorl %edi, %edi
callq 0x41e3e0
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/pingpong.c
// Function: common_setup
static void common_setup(thread_args_t *args) {
  // move to our target cpu
  if (sched_setaffinity(0, sizeof(cpu_set_t), &args->cpus)) {
    perror("sched_setaffinity");
    exit(1);
  }

  // test if we're supposed to allocate the pingpong_mutex memory
  if (args->me == 0) {
    pingpong_mutex = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
                          MAP_ANON | MAP_PRIVATE, -1, 0);
    if (pingpong_mutex == MAP_FAILED) {
      perror("mmap");
      exit(1);
    }
    *pingpong_mutex = args->me;
  }

  // ensure both threads are ready before we leave -- so that
  // both threads have a copy of pingpong_mutex.
  static pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER;
  static pthread_cond_t wait_cond = PTHREAD_COND_INITIALIZER;
  static int wait_for_buddy = 1;
  pthread_mutex_lock(&wait_mutex);
  if (wait_for_buddy) {
    wait_for_buddy = 0;
    pthread_cond_wait(&wait_cond, &wait_mutex);
  } else {
    wait_for_buddy = 1;  // for next invocation
    pthread_cond_broadcast(&wait_cond);
  }
  pthread_mutex_unlock(&wait_mutex);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x80, %esi
xorl %edi, %edi
movq %rbx, %rdx
callq 0x456d90
testl %eax, %eax
jne 0x401f9f
cmpl $0x0, 0x80(%rbx)
jne 0x401f4e
callq 0x457dd0
movslq %eax, %rsi
pushq $0x3
popq %rdx
pushq $0x22
popq %rcx
pushq $-0x1
popq %r8
xorl %edi, %edi
xorl %r9d, %r9d
callq 0x457ed0
movq %rax, 0xe80c8(%rip)     # 0x4ea008
cmpq $-0x1, %rax
je 0x401fa8
movl 0x80(%rbx), %ecx
movl %ecx, (%rax)
leaq 0xe80bb(%rip), %rdi     # 0x4ea010
callq 0x41fcf0
cmpb $0x0, 0xe8107(%rip)     # 0x4ea068
je 0x401f78
movb $0x0, 0xe80fe(%rip)     # 0x4ea068
leaq 0xe80c7(%rip), %rdi     # 0x4ea038
callq 0x41baa0
jmp 0x401f92
movb $0x1, 0xe80e9(%rip)     # 0x4ea068
leaq 0xe80b2(%rip), %rdi     # 0x4ea038
leaq 0xe8083(%rip), %rsi     # 0x4ea010
callq 0x41c0f0
leaq 0xe8077(%rip), %rdi     # 0x4ea010
popq %rbx
jmp 0x420bd0
leaq 0xb2234(%rip), %rdi     # 0x4b41da
jmp 0x401faf
leaq 0xb223d(%rip), %rdi     # 0x4b41ec
callq 0x40c110
pushq $0x1
popq %rdi
callq 0x40b2f0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/tudurom[P]disputils/lsd.c
// Function: main
int
main(int argc, char *argv[])
{
	xcb_randr_get_output_info_reply_t *output_info;
	xcb_randr_get_crtc_info_reply_t   *output_crtc_info;
	int print_all = 0;
	if (argc > 1 && strcmp(argv[1], "-a") == 0)
		print_all = 1;

#ifdef __OpenBSD__
	if (pledge("stdio rpath unix", NULL) == -1)
		err(1, "pledge");
#endif
	if (argc > 1 && (argc == 2 && !print_all))
		usage(argv[0]);
	init_xcb(&conn);
	get_screen(conn, &scrn);

	xcb_randr_provider_t *providers;
	int p_len = get_providers(conn, scrn, &providers);

	for (int i = 0; i < p_len; i++) {
		xcb_randr_output_t *os;
		int o_len = get_outputs(conn, providers[i], &os);

		/* Print screens from providers */
		for (int j = 0; j < o_len; j++) {
			output_info = get_output_info(conn, os[j]);
			output_crtc_info = get_output_crtc_info(conn, output_info->crtc);
			/* Print screen only if in use */
			if (print_all || output_crtc_info != NULL) {
				print_output(conn, os[j]);
			}
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x0, %r13d
cmpl $0x2, %edi
jl 0x13a8
movq 0x8(%rsi), %rax
cmpb $0x2d, (%rax)
jne 0x1397
cmpb $0x61, 0x1(%rax)
jne 0x1397
cmpb $0x0, 0x2(%rax)
sete %r13b
jmp 0x139a
xorl %r13d, %r13d
cmpl $0x2, %edi
jne 0x13a8
testb %r13b, %r13b
je 0x148c
leaq 0x2d79(%rip), %rdi      # 0x4128
callq 0x1494
movq 0x2d6d(%rip), %rdi      # 0x4128
leaq 0x2d6e(%rip), %rsi      # 0x4130
callq 0x14d0
movq 0x2d5a(%rip), %rdi      # 0x4128
movq 0x2d5b(%rip), %rsi      # 0x4130
leaq 0x10(%rsp), %rdx
callq 0x14fc
movl %eax, %ebx
testl %eax, %eax
movl $0x0, %eax
cmovlel %eax, %ebx
leaq 0x8(%rsp), %r14
xorl %ebp, %ebp
cmpq %rbx, %rbp
je 0x147b
movq 0x2d26(%rip), %rdi      # 0x4128
movq 0x10(%rsp), %rax
movl (%rax,%rbp,4), %esi
movq %r14, %rdx
callq 0x154c
movl %eax, %r15d
testl %eax, %eax
movl $0x0, %eax
cmovlel %eax, %r15d
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x1473
movq 0x2cf9(%rip), %rdi      # 0x4128
movq 0x8(%rsp), %rax
movl (%rax,%r12,4), %esi
callq 0x159c
movq 0x2ce4(%rip), %rdi      # 0x4128
movl 0xc(%rax), %esi
callq 0x163c
testq %rax, %rax
setne %al
orb %r13b, %al
cmpb $0x1, %al
jne 0x146e
movq 0x2cc8(%rip), %rdi      # 0x4128
movq 0x8(%rsp), %rax
movl (%rax,%r12,4), %esi
callq 0x1335
incq %r12
jmp 0x1423
incq %rbp
jmp 0x13f2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsi), %rdi
callq 0x131c
// File: /workspace/github_c_makefile_star2_O2/ijleesw[P]data-compression/src/golomb/encode.c
// Function: get_run_length_decoding
int 
get_run_length_decoding (unsigned int *in,
    unsigned long size,
    unsigned char **out,
    unsigned long *outsize)
{
  int i;
  int currindex, bytecounter;
  unsigned char *currbyte;

  currindex = 0;
  bytecounter = 1;

  memset (rle_buf, 0, sizeof(unsigned int) * MAX_INPUT_SIZE);
  currbyte = (unsigned char*) rle_buf;

  //printf ("last at %d: %d\n", size, in[size-1]);

  for (i = 0; i < size; ++i) {
    currindex += in[i];
    while (currindex > 8) {
      currbyte++;
      currindex -= 8;
      bytecounter++;
    }
    *currbyte |= 1 << (8 - currindex);
    //printf ("setting bit %d of byte %d\n", 
        //currindex, bytecounter);
  }

  *outsize = bytecounter - 1;
  if ( !(*out= (unsigned char *) malloc (*outsize)) ) {
    perror ("RLD: cannot malloc: ");
    return 1;
  }

  if ( !(memcpy (*out, rle_buf, *outsize)) ) {
    perror ("RLD: cannot memcpy: ");
    free (*out);
    return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x4952(%rip), %r13      # 0x6f20
xorl %ebp, %ebp
movl $0x1000000, %edx        # imm = 0x1000000
movq %r13, %rdi
xorl %esi, %esi
callq 0x20c0
pushq $0x1
popq %rax
pushq $0x8
popq %rdx
xorl %edi, %edi
movl %eax, %esi
cmpq %rbp, %r15
je 0x262d
addl (%r12,%rbp,4), %edi
cmpl $0x8, %edi
movl %edx, %ecx
cmovll %edi, %ecx
movl %edi, %r8d
subl %ecx, %r8d
addl $0x7, %r8d
movl %r8d, %r9d
andl $-0x8, %r8d
subl %r8d, %edi
movb $0x8, %cl
subb %dil, %cl
movl %eax, %r8d
shll %cl, %r8d
shrl $0x3, %r9d
orb %r8b, (%r13,%r9)
addl %r9d, %esi
addq %r9, %r13
incq %rbp
jmp 0x25e9
decl %esi
movslq %esi, %r15
movq %r15, (%r14)
movq %r15, %rdi
callq 0x2170
movq %rax, (%rbx)
testq %rax, %rax
je 0x2668
leaq 0x48d4(%rip), %rsi      # 0x6f20
movq %rax, %rdi
movq %r15, %rdx
callq 0x2140
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b9f(%rip), %rdi      # 0x420e
callq 0x21d0
pushq $0x1
popq %rax
jmp 0x2659
// File: /workspace/github_c_makefile_star2_O2/ijleesw[P]data-compression/src/golomb/encode.c
// Function: ceil_log2
int
ceil_log2 (int b) {
  int last = -1, secondlast = -1, count = 0;
  int log2_b, tmp = b;

  while (tmp) {
    if (tmp & 1) {
      secondlast = last;
      last = count;
    }
    tmp >>= 1;
    ++count;
  }
  if (secondlast == -1)
    log2_b = last;
  else
    log2_b = last+1;

  return log2_b;
}

// Assembly:
xorl %ecx, %ecx
pushq $-0x1
popq %rax
movl %eax, %edx
testl %edi, %edi
je 0x2698
testb $0x1, %dil
movl %ecx, %esi
cmovel %eax, %esi
cmovnel %eax, %edx
sarl %edi
incl %ecx
movl %esi, %eax
jmp 0x2680
xorl %ecx, %ecx
cmpl $-0x1, %edx
setne %cl
addl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ijleesw[P]data-compression/src/golomb/encode.c
// Function: zerr
void zerr(int ret)
{
  fputs("zpipe: ", stderr);
  switch (ret) {
    case Z_ERRNO:
      if (ferror(stdin))
        fputs("error reading stdin\n", stderr);
      if (ferror(stdout))
        fputs("error writing stdout\n", stderr);
      break;
    case Z_STREAM_ERROR:
      fputs("invalid compression level\n", stderr);
      break;
    case Z_DATA_ERROR:
      fputs("invalid or incomplete deflate data\n", stderr);
      break;
    case Z_MEM_ERROR:
      fputs("out of memory\n", stderr);
      break;
    case Z_VERSION_ERROR:
      fputs("zlib version mismatch!\n", stderr);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x303c(%rip), %r14      # 0x5ff8
movq (%r14), %rsi
leaq 0x13f0(%rip), %rdi      # 0x43b6
callq 0x20a0
addl $0x6, %ebx
cmpl $0x5, %ebx
ja 0x3009
leaq 0x1106(%rip), %rax      # 0x40e0
movslq (%rax,%rbx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x2fee(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
callq 0x2050
testl %eax, %eax
jne 0x3035
movq 0x2fd3(%rip), %rax      # 0x5fd0
movq (%rax), %rdi
callq 0x2050
testl %eax, %eax
jne 0x3046
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x13d1(%rip), %rdi      # 0x43e9
jmp 0x304d
leaq 0x1416(%rip), %rdi      # 0x4437
jmp 0x304d
leaq 0x13da(%rip), %rdi      # 0x4404
jmp 0x304d
leaq 0x13f5(%rip), %rdi      # 0x4428
jmp 0x304d
movq (%r14), %rsi
leaq 0x137f(%rip), %rdi      # 0x43be
callq 0x20a0
jmp 0x2ff6
leaq 0x1386(%rip), %rdi      # 0x43d3
movq (%r14), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20a0
// File: /workspace/github_c_makefile_star2_O2/ijleesw[P]data-compression/src/golomb/readfile.c
// Function: readFile
char *readFile(char *fileName) {
    FILE *file = fopen(fileName, "r");
    char *code;
    size_t n = 0;
    int c;

    if (file == NULL) return NULL; //could not open file
    fseek(file, 0, SEEK_END);
    long f_size = ftell(file);
    fseek(file, 0, SEEK_SET);
    code = (char*)malloc(f_size+1);

    while ((c = fgetc(file)) != EOF) {
        code[n++] = (char)c;
    }

    code[n] = '\0';        

    return code;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1447(%rip), %rsi      # 0x44af
callq 0x21c0
testq %rax, %rax
je 0x30c5
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2180
movq %rbx, %rdi
callq 0x2130
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2180
incq %r14
movq %r14, %rdi
callq 0x2170
movq %rax, %r14
movq %rax, %r15
movq %rbx, %rdi
callq 0x20d0
cmpl $-0x1, %eax
je 0x30bf
movb %al, (%r15)
incq %r15
jmp 0x30aa
movb $0x0, (%r15)
jmp 0x30c8
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/g3ida[P]g3idaCompiler/util.c
// Function: idExists
int idExists(const char* name) {
    int i;
	for(i=0; i< idTableMax; ++i) {
        if(strcmp(idTable[i].id, name) == 0) {
            idTable[i].used++;
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x4e8a(%rip), %r15d     # 0x60d8
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
leaq 0x4e91(%rip), %r12      # 0x60f0
pushq $-0x1
popq %rbp
cmpq %r14, %r15
je 0x1288
movq -0x10(%r12), %rdi
movq %rbx, %rsi
callq 0x10c0
testl %eax, %eax
je 0x1281
incq %r14
addq $0x18, %r12
jmp 0x1262
incl (%r12)
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/g3ida[P]g3idaCompiler/util.c
// Function: addID
int addID(const char* name)
{
    int ret = idExists(name);
    if(ret == -1) {
        idTable[idTableMax].id = copyString(name);
        idTable[idTableMax].type = Void;
        idTable[idTableMax].used = 0;
        ret = ++idTableMax;
    }
    return ret;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x123c
cmpl $-0x1, %eax
jne 0x12d2
movq %rbx, %rdi
callq 0x12d4
movslq 0x4e28(%rip), %rcx      # 0x60d8
imulq $0x18, %rcx, %rdx
leaq 0x4e25(%rip), %rsi      # 0x60e0
movq %rax, (%rdx,%rsi)
andl $0x0, 0x8(%rdx,%rsi)
andl $0x0, 0x10(%rdx,%rsi)
leal 0x1(%rcx), %eax
movl %eax, 0x4e06(%rip)      # 0x60d8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/g3ida[P]g3idaCompiler/util.c
// Function: copyString
char * copyString(const char * s)
{ int n;
  char * t;
  if (s==NULL) return NULL;
  n = strlen(s)+1;
  t = malloc(n);
  if (t==NULL)
    printf("Out of memory error at line %d\n",lineno);
  else strcpy(t,s);
  return t;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1311
movq %rdi, %rbx
callq 0x1080
incl %eax
movslq %eax, %rdi
callq 0x10e0
testq %rax, %rax
je 0x12fd
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1050
movl 0x4dad(%rip), %esi      # 0x60b0
leaq 0x1d33(%rip), %rdi      # 0x303d
xorl %eax, %eax
callq 0x10a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/g3ida[P]g3idaCompiler/parse.c
// Function: parse
void parse(void)
{
  token = analLex();
  program();
  printf("compilation ended with %d errors\n", errorCount);
  fclose(output);
  if(Error) {
    #ifdef __linux__
        system("rm out.txt");
    #else
    #ifdef __WIN32
        system("del /f out.txt");
    #endif
    #endif
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2208
movl %eax, 0x5716(%rip)      # 0x6a54
pushq $0x2
popq %rdi
callq 0x14db
leaq 0x5723(%rip), %r14      # 0x6a70
movq %r14, %rdi
callq 0x1293
xorl %edi, %edi
callq 0x14db
leaq 0x4d75(%rip), %r15      # 0x60d8
leaq 0x1db6(%rip), %r13      # 0x3120
pushq $0x25
popq %rbx
leaq 0x4d6c(%rip), %rbp      # 0x60e0
addq $0x20, %rbp
pushq $0x21
popq %rdi
callq 0x14db
cmpl $0x3, 0x56cd(%rip)      # 0x6a54
jne 0x1441
pushq $0x3
popq %rdi
callq 0x14db
movq %r14, %rdi
callq 0x1293
movl (%r15), %ecx
decl %ecx
cmpl %ecx, %eax
je 0x13ba
xorl %edi, %edi
callq 0x14db
cmpl $0x25, 0x56a0(%rip)     # 0x6a54
jne 0x13f6
movl %ebx, %edi
jmp 0x1390
leaq 0x4cef(%rip), %rax      # 0x60b0
movl (%rax), %esi
leaq 0x1d17(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movq %r13, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
leaq 0x4cef(%rip), %rax      # 0x60d4
incl (%rax)
leaq 0x4ce2(%rip), %rax      # 0x60d0
movl $0x1, (%rax)
jmp 0x13a6
pushq $0x24
popq %rdi
callq 0x14db
movl 0x5650(%rip), %edi      # 0x6a54
pushq $0x1
popq %r12
cmpl $0x6, %edi
je 0x1419
xorl %r12d, %r12d
cmpl $0x7, %edi
jne 0x141e
pushq $0x2
popq %r12
callq 0x14db
movslq (%r15), %rax
movq %rbp, %rcx
pushq $0x1
popq %rdx
cmpq %rax, %rdx
jge 0x1378
cmpl $0x0, (%rcx)
jne 0x1438
movl %r12d, (%rcx)
incq %rdx
addq $0x18, %rcx
jmp 0x1427
pushq $0x4
popq %rdi
callq 0x14db
movl 0x5605(%rip), %eax      # 0x6a54
cmpl $0x5, %eax
je 0x1459
cmpl $0x20, %eax
jne 0x14c1
pushq $0x5
popq %rdi
callq 0x14db
pushq $0x26
popq %rdi
callq 0x14db
leaq 0x4c64(%rip), %rax      # 0x60d4
movl (%rax), %esi
leaq 0x1c3b(%rip), %rdi      # 0x30b4
xorl %eax, %eax
callq 0x10a0
movq 0x55c1(%rip), %rdi      # 0x6a48
callq 0x1070
leaq 0x4c3d(%rip), %rax      # 0x60d0
cmpl $0x0, (%rax)
je 0x14b2
leaq 0x1c37(%rip), %rdi      # 0x30d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1090
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x21
popq %rbx
callq 0x1565
cmpl $0x21, 0x5584(%rip)     # 0x6a54
jne 0x1459
movl %ebx, %edi
callq 0x14db
jmp 0x14c4
// File: /workspace/github_c_makefile_star2_O2/g3ida[P]g3idaCompiler/parse.c
// Function: accepter
static void accepter(Symbole expected)
{ if (token == expected) token = analLex();
  else {
    ERROR_MSG("unexpected symbol '");
    printSymbole(token,lexeme);
    printf("'. Expected : '");
    printSymbole(expected,"");
    printf("\n");
  }
}

// Assembly:
pushq %rbx
cmpl %edi, 0x5572(%rip)      # 0x6a54
jne 0x14f1
callq 0x2208
movl %eax, 0x5565(%rip)      # 0x6a54
popq %rbx
retq
movl %edi, %ebx
leaq 0x4bb6(%rip), %rax      # 0x60b0
movl (%rax), %esi
leaq 0x1bde(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
leaq 0x1beb(%rip), %rdi      # 0x30fc
xorl %eax, %eax
callq 0x10a0
leaq 0x4bb5(%rip), %rax      # 0x60d4
incl (%rax)
leaq 0x4ba8(%rip), %rax      # 0x60d0
movl $0x1, (%rax)
movl 0x5520(%rip), %edi      # 0x6a54
leaq 0x5535(%rip), %rsi      # 0x6a70
callq 0x2070
leaq 0x1bc9(%rip), %rdi      # 0x3110
xorl %eax, %eax
callq 0x10a0
leaq 0x1d28(%rip), %rsi      # 0x327d
movl %ebx, %edi
callq 0x2070
pushq $0xa
popq %rdi
popq %rbx
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/g3ida[P]g3idaCompiler/parse.c
// Function: expr
exprType expr(void)
{
    exprType tlhs, trhs;
    Symbole op;
    tlhs = simple_expr();
    op = token;
    if ((token==LT)||(token==EQ)||(token==NEQ)|| (token==LTE) || (token==GT) || (token==GTE)) {
        accepter(token);
        trhs = simple_expr();
        if(trhs != tlhs && tlhs !=TypeError) {
            ERROR_MSG("type misaccepter cannot convert %s to %s\n", typeToStr(trhs), typeToStr(tlhs));

         tlhs = TypeError;
        }

        switch(op) {
        case LT:
            EMETTRE("comparer-si-inf\n");
            CONDITION_FLAG = 0;
            break;
        case GT:
            EMETTRE("comparer-si-sup\n");
            CONDITION_FLAG = 0;
            break;
        case EQ:
            EMETTRE( "comparer-si-egal\n");
            CONDITION_FLAG = 0;
            break;
        case LTE:
            EMETTRE("comparer-si-sup\n");
            CONDITION_FLAG = 1;
            break;
        case GTE:
            EMETTRE("comparer-si-inf\n");
            CONDITION_FLAG = 1;
            break;
        case NEQ:
            EMETTRE( "comparer-si-egal\n");
            CONDITION_FLAG = 1;
            break;
        default:
            break;
        }
        tlhs = Boolean;
    }
    return tlhs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x1c5a
movl %eax, %ebx
movl 0x4ef5(%rip), %edi      # 0x6a54
leal -0x13(%rdi), %r15d
cmpl $0x5, %r15d
ja 0x1c4d
callq 0x14db
callq 0x1c5a
movl %eax, %ebp
cmpl %ebx, %eax
sete %al
cmpl $0x4, %ebx
sete %cl
orb %al, %cl
jne 0x1bda
leaq 0x4521(%rip), %rax      # 0x60b0
movl (%rax), %esi
leaq 0x1549(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %ebp, %edi
callq 0x1315
movq %rax, %r14
movl %ebx, %edi
callq 0x1315
leaq 0x15d3(%rip), %rdi      # 0x318a
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
leaq 0x4509(%rip), %rax      # 0x60d4
incl (%rax)
leaq 0x44fc(%rip), %rax      # 0x60d0
movl $0x1, (%rax)
movq 0x4e67(%rip), %rcx      # 0x6a48
leaq 0x14b4(%rip), %rax      # 0x309c
movslq (%rax,%r15,4), %rdx
addq %rax, %rdx
jmpq *%rdx
leaq 0x15de(%rip), %rdi      # 0x31d6
pushq $0x11
jmp 0x1c17
leaq 0x15c2(%rip), %rdi      # 0x31c5
jmp 0x1c36
leaq 0x15a8(%rip), %rdi      # 0x31b4
jmp 0x1c15
leaq 0x15b0(%rip), %rdi      # 0x31c5
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x1120
xorl %eax, %eax
jmp 0x1c44
leaq 0x15ab(%rip), %rdi      # 0x31d6
pushq $0x11
jmp 0x1c38
leaq 0x157e(%rip), %rdi      # 0x31b4
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x1120
pushq $0x1
popq %rax
movl %eax, 0x4e06(%rip)      # 0x6a50
pushq $0x3
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/g3ida[P]g3idaCompiler/parse.c
// Function: simple_expr
exprType simple_expr(void)
{
    exprType tlhs, trhs;
    char* opstr;
    tlhs = term();
    while ((token==PLUS)||(token==MINUS) || (token==OR))
    {
        opstr = copyString(lexeme);
        if(token == OR) {
        if(tlhs != Boolean && tlhs !=TypeError) {
            ERROR_MSG("expected Boolean operand for 'OR' operator (found %s)\n", typeToStr(tlhs));
            tlhs = TypeError;
        }
      }
      accepter(token);
      trhs = term();
      if(trhs != tlhs && tlhs !=TypeError) {
         ERROR_MSG("type mismatch cannot convert %s to %s\n", typeToStr(trhs), typeToStr(tlhs));
         tlhs = TypeError;
      }
      EMETTRE("%s\n", opstr);
      free(opstr);
    }
    return tlhs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1d9e
movl %eax, %ebp
leaq 0x445d(%rip), %r14      # 0x60d0
pushq $0x4
popq %rbx
leaq 0x1997(%rip), %r13      # 0x3614
movl 0x4dd1(%rip), %eax      # 0x6a54
addl $-0x19, %eax
cmpl $0x2, %eax
ja 0x1d8d
leaq 0x4dda(%rip), %rdi      # 0x6a70
callq 0x12d4
movq %rax, %r15
movl 0x4db0(%rip), %edi      # 0x6a54
cmpl $0x1b, %edi
sete %al
leal -0x5(%rbp), %ecx
cmpl $-0x2, %ecx
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1d01
leaq 0x43ef(%rip), %rax      # 0x60b0
movl (%rax), %esi
leaq 0x1417(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %ebp, %edi
callq 0x1315
leaq 0x1509(%rip), %rdi      # 0x31e8
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
leaq 0x43e4(%rip), %rax      # 0x60d4
incl (%rax)
movl $0x1, (%r14)
movl 0x4d55(%rip), %edi      # 0x6a54
movl %ebx, %ebp
callq 0x14db
callq 0x1d9e
movl %eax, %r12d
cmpl %ebp, %eax
sete %al
cmpl $0x4, %ebp
sete %cl
orb %al, %cl
jne 0x1d6c
leaq 0x438c(%rip), %rax      # 0x60b0
movl (%rax), %esi
leaq 0x13b4(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %r12d, %edi
callq 0x1315
movq %rax, %r12
movl %ebp, %edi
callq 0x1315
leaq 0x14d2(%rip), %rdi      # 0x321f
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
leaq 0x4373(%rip), %rax      # 0x60d4
incl (%rax)
movl $0x1, (%r14)
movl %ebx, %ebp
movq 0x4cd5(%rip), %rdi      # 0x6a48
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10d0
movq %r15, %rdi
callq 0x1030
jmp 0x1c7d
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_O2/g3ida[P]g3idaCompiler/parse.c
// Function: term
exprType term(void)
{
    exprType tlhs, trhs;
    char* opstr;
    tlhs = factor();
    while ((token==MULT)||(token==DIV) || (token == MOD) || (token == AND))
    {
      opstr = copyString(lexeme);
      if(token == AND) {
        if(tlhs != Boolean && tlhs !=TypeError) {
            ERROR_MSG("expected Boolean operand for 'AND' operator (found %s)\n", typeToStr(tlhs));
            tlhs = TypeError;
        }
      }
      accepter(token);
      trhs = factor();
      if(trhs != tlhs && tlhs !=TypeError) {
         ERROR_MSG("type mismatch cannot convert %s to %s\n", typeToStr(trhs), typeToStr(tlhs));
         tlhs = TypeError;
      }
      EMETTRE("%s\n", opstr);
      free(opstr);
    }
    return tlhs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1ee2
movl %eax, %ebp
leaq 0x4319(%rip), %r14      # 0x60d0
pushq $0x4
popq %rbx
leaq 0x1853(%rip), %r13      # 0x3614
movl 0x4c8d(%rip), %eax      # 0x6a54
andl $-0x4, %eax
cmpl $0x1c, %eax
jne 0x1ed1
leaq 0x4c96(%rip), %rdi      # 0x6a70
callq 0x12d4
movq %rax, %r15
movl 0x4c6c(%rip), %edi      # 0x6a54
cmpl $0x1c, %edi
sete %al
leal -0x5(%rbp), %ecx
cmpl $-0x2, %ecx
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1e45
leaq 0x42ab(%rip), %rax      # 0x60b0
movl (%rax), %esi
leaq 0x12d3(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %ebp, %edi
callq 0x1315
leaq 0x1423(%rip), %rdi      # 0x3246
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
leaq 0x42a0(%rip), %rax      # 0x60d4
incl (%rax)
movl $0x1, (%r14)
movl 0x4c11(%rip), %edi      # 0x6a54
movl %ebx, %ebp
callq 0x14db
callq 0x1ee2
movl %eax, %r12d
cmpl %ebp, %eax
sete %al
cmpl $0x4, %ebp
sete %cl
orb %al, %cl
jne 0x1eb0
leaq 0x4248(%rip), %rax      # 0x60b0
movl (%rax), %esi
leaq 0x1270(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
movl %r12d, %edi
callq 0x1315
movq %rax, %r12
movl %ebp, %edi
callq 0x1315
leaq 0x138e(%rip), %rdi      # 0x321f
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
leaq 0x422f(%rip), %rax      # 0x60d4
incl (%rax)
movl $0x1, (%r14)
movl %ebx, %ebp
movq 0x4b91(%rip), %rdi      # 0x6a48
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10d0
movq %r15, %rdi
callq 0x1030
jmp 0x1dc1
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_O2/g3ida[P]g3idaCompiler/parse.c
// Function: factor
exprType factor(void)
{
    exprType t = Void;
    int p;
    switch (token) {
    case NUM :
        EMETTRE("empiler %d\n", atoi(lexeme));
        accepter(NUM);
        t = Integer;
        break;
    case ID :
        EMETTRE("valeurd %s\n",lexeme);
        if((p = idExists(lexeme)) == -1) {
            ERROR_MSG("variable '%s' undeclared\n", lexeme);
        }
        t = idTable[p].type;
        accepter(ID);
      break;
    case LPAREN:
        accepter(LPAREN);
        t = simple_expr();
        accepter(RPAREN);
        break;
    default:
        EMETTRE("halte\n");
        ERROR_MSG("unexprected symbol '");
        printSymbole(token,lexeme);
        printf("' \n");
        printSymbole(token,lexeme);
        token = analLex();
        break;
    }
    return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x4b68(%rip), %eax      # 0x6a54
testl %eax, %eax
je 0x1f45
cmpl $0x11, %eax
je 0x1f2e
cmpl $0x1, %eax
jne 0x1fd3
movq 0x4b43(%rip), %rbx      # 0x6a48
leaq 0x4b64(%rip), %rdi      # 0x6a70
callq 0x1110
leaq 0x1366(%rip), %rsi      # 0x327e
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x10d0
pushq $0x1
popq %rbx
movl %ebx, %edi
jmp 0x1fc9
pushq $0x11
popq %rdi
callq 0x14db
callq 0x1c5a
movl %eax, %ebx
pushq $0x12
popq %rdi
jmp 0x1fc9
movq 0x4afc(%rip), %rdi      # 0x6a48
leaq 0x1337(%rip), %rsi      # 0x328a
leaq 0x4b16(%rip), %rbx      # 0x6a70
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10d0
movq %rbx, %rdi
callq 0x123c
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x1fb5
leaq 0x4136(%rip), %rax      # 0x60b0
movl (%rax), %esi
leaq 0x115e(%rip), %rdi      # 0x30e1
xorl %eax, %eax
callq 0x10a0
leaq 0x1305(%rip), %rdi      # 0x3296
leaq 0x4ad8(%rip), %rsi      # 0x6a70
xorl %eax, %eax
callq 0x10a0
leaq 0x412e(%rip), %rax      # 0x60d4
incl (%rax)
leaq 0x4121(%rip), %rax      # 0x60d0
movl $0x1, (%rax)
movslq %ebx, %rax
imulq $0x18, %rax, %rax
leaq 0x411d(%rip), %rcx      # 0x60e0
movl 0x8(%rcx,%rax), %ebx
xorl %edi, %edi
callq 0x14db
jmp 0x2063
movq 0x4a6e(%rip), %rcx      # 0x6a48
leaq 0x12cf(%rip), %rdi      # 0x32b0
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
callq 0x1120
leaq 0x40bd(%rip), %rax      # 0x60b0
movl (%rax), %esi
leaq 0x10e5(%rip), %rdi      # 0x30e1
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10a0
leaq 0x12ab(%rip), %rdi      # 0x32b7
xorl %eax, %eax
callq 0x10a0
leaq 0x40ba(%rip), %rax      # 0x60d4
incl (%rax)
leaq 0x40ad(%rip), %rax      # 0x60d0
movl $0x1, (%rax)
movl 0x4a25(%rip), %edi      # 0x6a54
leaq 0x4a3a(%rip), %r14      # 0x6a70
movq %r14, %rsi
callq 0x2070
leaq 0x1334(%rip), %rdi      # 0x3379
callq 0x1060
movl 0x4a04(%rip), %edi      # 0x6a54
movq %r14, %rsi
callq 0x2070
callq 0x2208
movl %eax, 0x49f1(%rip)      # 0x6a54
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/g3ida[P]g3idaCompiler/main.c
// Function: main
int main(int argc, char* argv[])
{
	int i;
    if(argc <= 1) {
        printf(" g3idaCompiler: fatal error no input files\n");
        return 0;
    }

    input = fopen(argv[1], "r");
    if(input == NULL) {
        printf(" g3idaCompiler: fatal error file not found %s\n", argv[1]);
        return -1;
    }

    output = fopen("out.txt", "w");

    parse();

    for(i=1; i<idTableMax; ++i) {
        if(!idTable[i].used)
        printf("WARNING : variable '%s' declared but not used\n", idTable[i].id);
    }

    fclose(input);


    #ifdef __WIN32
        system("PAUSE");
    #endif

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x1, %edi
jg 0x262b
leaq 0x1028(%rip), %rdi      # 0x3649
callq 0x1060
jmp 0x26c5
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
leaq 0x9ef(%rip), %rsi       # 0x3028
callq 0x1100
leaq 0x441b(%rip), %r14      # 0x6a60
movq %rax, (%r14)
testq %rax, %rax
je 0x26d1
leaq 0xa81(%rip), %rdi       # 0x30d9
leaq 0xfb9(%rip), %rsi       # 0x3618
callq 0x1100
leaq 0x43dd(%rip), %rcx      # 0x6a48
movq %rax, (%rcx)
callq 0x1328
leaq 0x3a66(%rip), %r15      # 0x60e0
addq $0x28, %r15
leaq 0x3a53(%rip), %r12      # 0x60d8
movl (%r12), %eax
pushq $0x1
popq %r13
leaq 0xf86(%rip), %rbx       # 0x361a
movslq %eax, %rcx
cmpq %rcx, %r13
jge 0x26bd
cmpl $0x0, (%r15)
jne 0x26b4
movq -0x10(%r15), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a0
movl (%r12), %eax
incq %r13
addq $0x18, %r15
jmp 0x2694
movq (%r14), %rdi
callq 0x1070
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rsi
leaq 0xf0d(%rip), %rdi       # 0x35e9
xorl %eax, %eax
callq 0x10a0
pushq $-0x1
popq %rax
jmp 0x26c7
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_15/temperature_conversion.c
// Function: main
int main(void)
{
  float celsius, fahr;
  int lower, upper, step;

  lower = 0;
  upper = 300;
  step = 30;

  // Printing a heading abouve the table
  printf("Celsius\t\tFahr.\n");
  printf("----------------------\n");

  celsius = lower;
  while (celsius <= upper)
  {
    fahr = celsius_to_fahrenheit(celsius);
    printf("%3.0f\t\t%6.1f\n", celsius, fahr);
    celsius += step;
  }

  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xed6(%rip), %rdi       # 0x202e
callq 0x1030
leaq 0xed9(%rip), %rdi       # 0x203d
callq 0x1030
xorps %xmm0, %xmm0
leaq 0xead(%rip), %rbx       # 0x2020
movss 0xe89(%rip), %xmm1      # 0x2004
ucomiss %xmm0, %xmm1
jb 0x11c2
movaps %xmm0, (%rsp)
cvttps2dq (%rsp), %xmm0
cvtdq2pd %xmm0, %xmm0
mulsd 0xe7b(%rip), %xmm0      # 0x2010
addsd 0xe7b(%rip), %xmm0      # 0x2018
cvtsd2ss %xmm0, %xmm1
cvtss2sd (%rsp), %xmm0
cvtss2sd %xmm1, %xmm1
movq %rbx, %rdi
movb $0x2, %al
callq 0x1040
movaps (%rsp), %xmm0
addss 0xe48(%rip), %xmm0      # 0x2008
jmp 0x1173
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/DrYerzinia[P]C_DigiMode/src/mixer/mixer.c
// Function: main
int main(int argc, char **argv){

	struct arguments arguments;
	argp_parse(&argp, argc, argv, 0, 0, &arguments);

	FILE *data_file1 = NULL;
	FILE *data_file2 = NULL;

	data_file1 = fopen(arguments.in_1_filename, "r");
	if(data_file1 == NULL){
		fprintf(stderr, "Error: couldn't open input file 1\n");
		return -1;
	}

	data_file2 = fopen(arguments.in_2_filename, "r");
	if(data_file2 == NULL){
		fprintf(stderr, "Error: couldn't open input file 2\n");
		fclose(data_file1);
		return -1;
	}

	FILE *output_file = fopen(arguments.out_filename, "w");
	if(output_file == NULL){
		fprintf(stderr, "Error: unable to create output file\n");
		fclose(data_file1);
		fclose(data_file2);
		return -1;
	}

	bool eof1 = false, eof2 = false;
	char byte1, byte2;

	while(!eof1 && !eof2){

		byte1 = getc(data_file1);
		byte2 = getc(data_file2);

		fputc(byte1*byte2/16384, output_file);

		eof1 = feof(data_file1);
		eof2 = feof(data_file2);

		if(eof1 != eof2){
			fprintf(stderr, "Error: input file sizes do not match!\n");
			return -1;
		}

	}

	fclose(data_file1);
	fclose(data_file2);
	fclose(output_file);

	return 0;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movl %edi, %esi
leaq 0x2ebc(%rip), %rdi      # 0x4070
leaq 0x8(%rsp), %rbx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x1050
movq (%rbx), %rdi
leaq 0xe55(%rip), %rsi       # 0x2025
callq 0x1070
testq %rax, %rax
je 0x12ac
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0xe38(%rip), %rsi       # 0x2025
callq 0x1070
testq %rax, %rax
je 0x12ca
movq %rax, %r14
movq 0x18(%rsp), %rdi
leaq 0xe63(%rip), %rsi       # 0x206d
callq 0x1070
testq %rax, %rax
je 0x12eb
movq %rax, %r15
xorl %ebp, %ebp
movw $0x4000, %r12w          # imm = 0x4000
xorl %eax, %eax
testb $0x1, %bpl
jne 0x1290
testb $0x1, %al
jne 0x1290
movq %rbx, %rdi
callq 0x1090
movl %eax, %ebp
movq %r14, %rdi
callq 0x1090
movsbl %bpl, %ecx
movsbl %al, %eax
imull %ecx, %eax
cwtd
idivw %r12w
movzwl %ax, %edi
movq %r15, %rsi
callq 0x1040
movq %rbx, %rdi
callq 0x1060
testl %eax, %eax
setne %bpl
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
setne %al
cmpb %al, %bpl
je 0x1224
movq 0x2d76(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xe08(%rip), %rdi       # 0x2094
pushq $0x26
jmp 0x12bf
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x131a
movq 0x2d45(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd6a(%rip), %rdi       # 0x2027
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x1080
jmp 0x1317
movq 0x2d27(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd6f(%rip), %rdi       # 0x204a
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x1080
movq %rbx, %rdi
jmp 0x1312
movq 0x2d06(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd73(%rip), %rdi       # 0x206f
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x1080
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
pushq $-0x1
popq %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq