LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15b44
movq 0x44ce(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x133a(%rip), %rsi      # 0x16e6e
movb $0x0, %al
callq 0x1080
movl $0x0, -0x4(%rbp)
jmp 0x15b9d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x15b70
movq 0x44a2(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x132e(%rip), %rsi      # 0x16e8e
movb $0x0, %al
callq 0x1080
movl $0x0, -0x4(%rbp)
jmp 0x15b9d
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15b83
movl $0x1, -0x4(%rbp)
jmp 0x15b9d
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x15bb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x15c0d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jl 0x15c0d
movq 0x4408(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x14c1(%rip), %rsi      # 0x170bb
movb $0x0, %al
callq 0x1080
movl $0x0, -0x4(%rbp)
jmp 0x15cc4
cmpq $0x0, -0x28(%rbp)
je 0x15c4f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq -0x28(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jl 0x15c4f
movq 0x43c3(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x147c(%rip), %rsi      # 0x170bb
movb $0x0, %al
callq 0x1080
movl $0x0, -0x4(%rbp)
jmp 0x15cc4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x15c86
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
callq 0x15bb0
cmpl $0x0, %eax
jne 0x15c84
movl $0x0, -0x4(%rbp)
jmp 0x15cc4
jmp 0x15c86
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x15cbd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0x15bb0
cmpl $0x0, %eax
jne 0x15cbb
movl $0x0, -0x4(%rbp)
jmp 0x15cc4
jmp 0x15cbd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15db5
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x15db5
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x15d27
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
leaq 0x1233(%rip), %rdx      # 0x16f55
callq 0x15dd0
movq 0x42aa(%rip), %rax      # 0x19fd8
movq (%rax), %rdi
leaq 0x122d(%rip), %rsi      # 0x16f65
movb $0x0, %al
callq 0x1080
cmpq $0x0, -0x10(%rbp)
jne 0x15d60
movq 0x428b(%rip), %rax      # 0x19fd8
movq (%rax), %rdi
leaq 0x96f(%rip), %rsi       # 0x166c6
movb $0x0, %al
callq 0x1080
jmp 0x15d70
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
callq *%rax
movq 0x4261(%rip), %rax      # 0x19fd8
movq (%rax), %rdi
leaq 0x350(%rip), %rsi       # 0x160d1
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x15db3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rcx
xorl %esi, %esi
leaq 0x11a7(%rip), %rdx      # 0x16f55
callq 0x15dd0
jmp 0x15db5
movq 0x421c(%rip), %rax      # 0x19fd8
movq (%rax), %rdi
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4024b0
movq 0xe8c64(%rip), %rax     # 0x4eb008
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movabsq $0x100000000, %rax      # imm = 0x100000000
movl $0x1, %ecx
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl 0xe8c1a(%rip), %eax     # 0x4eb000
cmpl $0x0, %eax
je 0x4023f4
xorl %eax, %eax
movl %eax, %edi
callq 0x41e5f0
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x38(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x402444
movl -0x2c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl %ecx, %eax
je 0x402444
movq -0x38(%rbp), %rax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x2710, -0x30(%rbp)    # imm = 0x2710
jne 0x402442
movl -0x30(%rbp), %eax
addl %eax, %eax
lock
addl %eax, 0xe87c5(%rip)     # 0x4eac00
movl $0x0, -0x30(%rbp)
jmp 0x402444
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq 0xe5cb9(%rip), %rax     # 0x4e8110
jae 0x40246c
callq 0x4025c0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x40244c
jmp 0x4023e0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
xorl %edi, %edi
movl $0x80, %esi
callq 0x456fd0
cmpl $0x0, %eax
je 0x4024e7
leaq 0xb2d95(%rip), %rdi     # 0x4b526d
callq 0x40c760
movl $0x1, %edi
callq 0x40b940
movq -0x8(%rbp), %rax
cmpl $0x0, 0x80(%rax)
jne 0x402559
callq 0x458010
movslq %eax, %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x458110
movq %rax, 0xe8ae8(%rip)     # 0x4eb008
movq $-0x1, %rax
cmpq %rax, 0xe8ada(%rip)     # 0x4eb008
jne 0x402546
leaq 0xb2d48(%rip), %rdi     # 0x4b527f
callq 0x40c760
movl $0x1, %edi
callq 0x40b940
movq -0x8(%rbp), %rax
movl 0x80(%rax), %ecx
movq 0xe8ab1(%rip), %rax     # 0x4eb008
movl %ecx, (%rax)
leaq 0xe8ab0(%rip), %rdi     # 0x4eb010
callq 0x41ff00
cmpl $0x0, 0xe5bb4(%rip)     # 0x4e8120
je 0x40258d
movl $0x0, 0xe5ba8(%rip)     # 0x4e8120
leaq 0xe8ab9(%rip), %rdi     # 0x4eb038
leaq 0xe8a8a(%rip), %rsi     # 0x4eb010
callq 0x41c300
jmp 0x4025a3
movl $0x1, 0xe5b89(%rip)     # 0x4e8120
leaq 0xe8a9a(%rip), %rdi     # 0x4eb038
callq 0x41bcb0
leaq 0xe8a66(%rip), %rdi     # 0x4eb010
callq 0x420de0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/google[P]multichase/pingpong.c
// Function: unlocked_xchg
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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x4025fb
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x402602
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x13e3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xc42(%rip), %rsi       # 0x2014
callq 0x1100
cmpl $0x0, %eax
jne 0x13e3
movl $0x1, -0x24(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x1401
cmpl $0x2, -0x8(%rbp)
jne 0x1401
cmpl $0x0, -0x24(%rbp)
jne 0x1401
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1320
leaq 0x2d20(%rip), %rdi      # 0x4128
callq 0x1500
movq 0x2d14(%rip), %rdi      # 0x4128
leaq 0x2d15(%rip), %rsi      # 0x4130
callq 0x1580
movq 0x2d01(%rip), %rdi      # 0x4128
movq 0x2d02(%rip), %rsi      # 0x4130
leaq -0x30(%rbp), %rdx
callq 0x15e0
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x14ed
movq 0x2cd4(%rip), %rdi      # 0x4128
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq -0x40(%rbp), %rdx
callq 0x1660
movl %eax, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x14dd
movq 0x2ca7(%rip), %rdi      # 0x4128
movq -0x40(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x16e0
movq %rax, -0x18(%rbp)
movq 0x2c8c(%rip), %rdi      # 0x4128
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x1820
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x14b9
cmpq $0x0, -0x20(%rbp)
je 0x14d0
movq 0x2c68(%rip), %rdi      # 0x4128
movq -0x40(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x1350
jmp 0x14d2
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x1472
jmp 0x14df
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1441
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
leaq 0x4621(%rip), %rdi      # 0x6f20
xorl %esi, %esi
movl $0x1000000, %edx        # imm = 0x1000000
callq 0x20c0
leaq 0x460e(%rip), %rax      # 0x6f20
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x2996
movq 0x38(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
cmpl $0x8, 0x18(%rsp)
jle 0x296d
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movl 0x18(%rsp), %eax
subl $0x8, %eax
movl %eax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2940
movl $0x8, %ecx
subl 0x18(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movq 0x8(%rsp), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x291f
movl 0x14(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x2180
movq 0x28(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x29d9
leaq 0x1852(%rip), %rdi      # 0x421c
callq 0x21e0
movl $0x1, 0x44(%rsp)
jmp 0x2a2e
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq %rdi, (%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdx
leaq 0x452c(%rip), %rsi      # 0x6f20
callq 0x2150
movq (%rsp), %rax
cmpq $0x0, %rax
jne 0x2a26
leaq 0x1827(%rip), %rdi      # 0x4231
callq 0x21e0
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x2030
movl $0x1, 0x44(%rsp)
jmp 0x2a2e
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0x4(%rsp)
movl $0xffffffff, -0x8(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xc(%rsp) # imm = 0xFFFFFFFF
movl $0x0, -0x10(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x18(%rsp)
cmpl $0x0, -0x18(%rsp)
je 0x2a9e
movl -0x18(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2a87
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x18(%rsp), %eax
sarl %eax
movl %eax, -0x18(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x2a64
cmpl $-0x1, -0xc(%rsp)
jne 0x2aaf
movl -0x8(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x2aba
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/golomb/encode.c
// Function: num_set_bits
static unsigned long 
num_set_bits (unsigned char *input, unsigned long size)
{
  unsigned long count = 0, i = 0;
  while (i < size)
    count += set_bits_lookup_table[input[i++]];
  return count;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x30cb
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x1045(%rip), %rax      # 0x4100
movzbl (%rax,%rcx), %eax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0x308c
movq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq 0x2329(%rip), %rax      # 0x5ff8
movq (%rax), %rsi
leaq 0x78b(%rip), %rdi       # 0x4464
callq 0x20a0
movl 0x14(%rsp), %eax
addl $0x6, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x5, %eax
ja 0x3dbe
movq 0x8(%rsp), %rax
leaq 0x3df(%rip), %rcx       # 0x40e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x22c7(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
callq 0x2050
cmpl $0x0, %eax
je 0x3d34
movq 0x22d3(%rip), %rax      # 0x5ff8
movq (%rax), %rsi
leaq 0x73d(%rip), %rdi       # 0x446c
callq 0x20a0
movq 0x2295(%rip), %rax      # 0x5fd0
movq (%rax), %rdi
callq 0x2050
cmpl $0x0, %eax
je 0x3d5e
movq 0x22a9(%rip), %rax      # 0x5ff8
movq (%rax), %rsi
leaq 0x728(%rip), %rdi       # 0x4481
callq 0x20a0
jmp 0x3dbe
movq 0x2291(%rip), %rax      # 0x5ff8
movq (%rax), %rsi
leaq 0x726(%rip), %rdi       # 0x4497
callq 0x20a0
jmp 0x3dbe
movq 0x2279(%rip), %rax      # 0x5ff8
movq (%rax), %rsi
leaq 0x729(%rip), %rdi       # 0x44b2
callq 0x20a0
jmp 0x3dbe
movq 0x2261(%rip), %rax      # 0x5ff8
movq (%rax), %rsi
leaq 0x735(%rip), %rdi       # 0x44d6
callq 0x20a0
jmp 0x3dbe
movq 0x2249(%rip), %rax      # 0x5ff8
movq (%rax), %rsi
leaq 0x72c(%rip), %rdi       # 0x44e5
callq 0x20a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x718(%rip), %rsi       # 0x44fd
callq 0x21d0
movq %rax, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x3e0e
movq $0x0, 0x30(%rsp)
jmp 0x3e9d
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2190
movq 0x20(%rsp), %rdi
callq 0x2140
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2190
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0x2180
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x20d0
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
je 0x3e85
movl 0xc(%rsp), %eax
movb %al, %dl
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x10(%rsp)
movb %dl, (%rax,%rcx)
jmp 0x3e51
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x4fbc(%rip), %eax      # 0x61e8
jge 0x1281
movslq -0x14(%rbp), %rcx
leaq 0x4fb7(%rip), %rax      # 0x61f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10a0
cmpl $0x0, %eax
jne 0x1274
movslq -0x14(%rbp), %rcx
leaq 0x4f94(%rip), %rax      # 0x61f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1288
jmp 0x1276
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1223
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1210
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x132c
movq -0x8(%rbp), %rdi
callq 0x1340
movq %rax, %rcx
movslq 0x4f17(%rip), %rdx      # 0x61e8
leaq 0x4f18(%rip), %rax      # 0x61f0
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movslq 0x4eff(%rip), %rcx      # 0x61e8
leaq 0x4f00(%rip), %rax      # 0x61f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movslq 0x4ee3(%rip), %rcx      # 0x61e8
leaq 0x4ee4(%rip), %rax      # 0x61f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x10(%rax)
movl 0x4ec8(%rip), %eax      # 0x61e8
addl $0x1, %eax
movl %eax, 0x4ebf(%rip)      # 0x61e8
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x135d
movq $0x0, -0x8(%rbp)
jmp 0x13ac
movq -0x10(%rbp), %rdi
callq 0x1060
addq $0x1, %rax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
callq 0x10c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1397
movl 0x4d19(%rip), %esi      # 0x60a0
leaq 0x2c9b(%rip), %rdi      # 0x4029
movb $0x0, %al
callq 0x1080
jmp 0x13a4
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1040
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
callq 0x29e0
movl %eax, 0x5775(%rip)      # 0x6b64
callq 0x1440
leaq 0x4de9(%rip), %rax      # 0x61e4
movl (%rax), %esi
leaq 0x2c9c(%rip), %rdi      # 0x40a0
movb $0x0, %al
callq 0x1080
movq 0x5746(%rip), %rdi      # 0x6b58
callq 0x1050
leaq 0x4dc2(%rip), %rax      # 0x61e0
cmpl $0x0, (%rax)
je 0x142f
leaq 0x2c98(%rip), %rdi      # 0x40c2
callq 0x1070
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: program
void program(void)
{
    accepter(PROGRAM);
    addID(lexeme);
    accepter(ID);
    accepter(SEMI);
    dcl();
    inst_composee();
    accepter(POINT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x2, %edi
callq 0x1490
leaq 0x572b(%rip), %rdi      # 0x6b80
callq 0x12a0
xorl %edi, %edi
callq 0x1490
movl $0x21, %edi
callq 0x1490
callq 0x1540
callq 0x15e0
movl $0x26, %edi
callq 0x1490
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x56c3(%rip), %eax      # 0x6b64
cmpl -0x4(%rbp), %eax
jne 0x14b6
callq 0x29e0
movl %eax, 0x56b3(%rip)      # 0x6b64
jmp 0x153a
leaq 0x4be3(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x2c07(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
leaq 0x2c14(%rip), %rdi      # 0x40e8
movb $0x0, %al
callq 0x1080
leaq 0x4d02(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4cf6(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x4ce9(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
movl 0x5661(%rip), %edi      # 0x6b64
leaq 0x5676(%rip), %rsi      # 0x6b80
callq 0x26b0
leaq 0x2be6(%rip), %rdi      # 0x40fc
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %edi
leaq 0x2dd3(%rip), %rsi      # 0x42fa
callq 0x26b0
leaq 0x2dc6(%rip), %rdi      # 0x42f9
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: dcl
void dcl(void)
{
    while(token == VAR) {
		int i;
        accepter(VAR);
        liste_id();
        accepter(TWOPTS);
        exprType t = type();
        for(i=1; i< idTableMax; i++) {
            if(idTable[i].type == Void) {
                idTable[i].type = t;
            }
        }
        accepter(SEMI);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x3, 0x5615(%rip)      # 0x6b64
jne 0x15d7
movl $0x3, %edi
callq 0x1490
callq 0x1620
movl $0x24, %edi
callq 0x1490
callq 0x1730
movl %eax, -0x8(%rbp)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x4c61(%rip), %rcx      # 0x61e8
cmpl (%rcx), %eax
jge 0x15c8
movslq -0x4(%rbp), %rcx
leaq 0x4c5a(%rip), %rax      # 0x61f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0x15bb
movl -0x8(%rbp), %ecx
movslq -0x4(%rbp), %rdx
leaq 0x4c3f(%rip), %rax      # 0x61f0
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
jmp 0x15bd
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x157d
movl $0x21, %edi
callq 0x1490
jmp 0x1548
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: inst_composee
void inst_composee(void)
{
    accepter(BEGIN);
    if(token != END && token != ENDFILE) {
        liste_inst();
    }
    accepter(END);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x4, %edi
callq 0x1490
cmpl $0x5, 0x556f(%rip)      # 0x6b64
je 0x1605
cmpl $0x20, 0x5566(%rip)     # 0x6b64
je 0x1605
callq 0x1790
movl $0x5, %edi
callq 0x1490
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: liste_id
void liste_id(void)
{
    if(addID(lexeme) == idTableMax-1) {
           ERROR_MSG("variable '%s' declared twice\n", lexeme);
    }
    accepter(ID);
    while(token == COMMA) {
        accepter(COMMA);
        if(addID(lexeme) == idTableMax-1) {
           ERROR_MSG("variable '%s' declared twice\n", lexeme);
        }
        accepter(ID);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x5555(%rip), %rdi      # 0x6b80
callq 0x12a0
leaq 0x4bb1(%rip), %rcx      # 0x61e8
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x168e
leaq 0x4a59(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x2a7d(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
leaq 0x2aae(%rip), %rdi      # 0x410c
leaq 0x551b(%rip), %rsi      # 0x6b80
movb $0x0, %al
callq 0x1080
leaq 0x4b71(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4b65(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x4b58(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
xorl %edi, %edi
callq 0x1490
cmpl $0x25, 0x54c8(%rip)     # 0x6b64
jne 0x1722
movl $0x25, %edi
callq 0x1490
leaq 0x54cd(%rip), %rdi      # 0x6b80
callq 0x12a0
leaq 0x4b29(%rip), %rcx      # 0x61e8
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1716
leaq 0x49d1(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x29f5(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
leaq 0x2a26(%rip), %rdi      # 0x410c
leaq 0x5493(%rip), %rsi      # 0x6b80
movb $0x0, %al
callq 0x1080
leaq 0x4ae9(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4add(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x4ad0(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
xorl %edi, %edi
callq 0x1490
jmp 0x1695
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: type
exprType type(void)
{
    switch(token) {
    case INTEGER :
        accepter(INTEGER);
        return Integer;
        break;
    case CHAR :
        accepter(CHAR);
        return Char;
        break;
    default:
        return Void;
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x5426(%rip), %eax      # 0x6b64
movl %eax, -0x8(%rbp)
subl $0x6, %eax
je 0x1752
jmp 0x1748
movl -0x8(%rbp), %eax
subl $0x7, %eax
je 0x1765
jmp 0x1778
movl $0x6, %edi
callq 0x1490
movl $0x1, -0x4(%rbp)
jmp 0x177f
movl $0x7, %edi
callq 0x1490
movl $0x2, -0x4(%rbp)
jmp 0x177f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: liste_inst
void liste_inst(void)
{
  statement();
  while ((token==SEMI))
  {
    accepter(SEMI);
    statement();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x17c0
cmpl $0x21, 0x53c4(%rip)     # 0x6b64
jne 0x17b3
movl $0x21, %edi
callq 0x1490
callq 0x17c0
jmp 0x1799
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: statement
void statement(void)
{
    switch (token) {
    case IF : if_stmt(); break;
    case WHILE :  while_stmt(); break;
    case ID : assign_stmt(); break;
    case READ : read_stmt(); break;
    case WRITE : write_stmt(); break;
    case READLN : readln_stmt(); break;
    case WRITELN : writeln_stmt(); break;
    default : ERROR_MSG("unexprected token ");
              printSymbole(token,lexeme);
              printf("\n");
              token = analLex();
              break;
    } /* end case */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x5396(%rip), %eax      # 0x6b64
movq %rax, -0x8(%rbp)
subq $0xe, %rax
ja 0x182c
movq -0x8(%rbp), %rax
leaq 0x2869(%rip), %rcx      # 0x404c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x18b0
jmp 0x189e
callq 0x1a00
jmp 0x189e
callq 0x1b40
jmp 0x189e
callq 0x1c90
jmp 0x189e
callq 0x1d60
jmp 0x189e
callq 0x1e30
jmp 0x189e
callq 0x1f00
jmp 0x189e
leaq 0x486d(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x2891(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
leaq 0x28e0(%rip), %rdi      # 0x412a
movb $0x0, %al
callq 0x1080
leaq 0x498c(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4980(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x4973(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
movl 0x52eb(%rip), %edi      # 0x6b64
leaq 0x5300(%rip), %rsi      # 0x6b80
callq 0x26b0
leaq 0x2a6d(%rip), %rdi      # 0x42f9
movb $0x0, %al
callq 0x1080
callq 0x29e0
movl %eax, 0x52c6(%rip)      # 0x6b64
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: if_stmt
void if_stmt(void)
{
    int else_etiq = NEXT_ETIQ, end_etiq = NEXT_ETIQ;
    exprType t;
    accepter(IF);
    t = expr();
    if(t != Boolean) {
        ERROR_MSG("expected Boolean expression as condition for the if statement\n");
    }
    if(CONDITION_FLAG) {
        EMETTRE("aller-si-vrai %d\n",else_etiq);
    } else {
        EMETTRE("aller-si-faux %d\n",else_etiq);
    }
    accepter(THEN);
    statement();
    /*inst_composee();*/

    EMETTRE("aller-a %d\n",end_etiq);
    accepter(ELSE);
    EMETTRE("etiq %d\n",else_etiq);
    statement();
    /*inst_composee();*/
    EMETTRE("etiq %d\n",end_etiq);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5291(%rip), %rax      # 0x6b50
movl (%rax), %eax
movl %eax, %edx
addl $0x1, %edx
leaq 0x5283(%rip), %rcx      # 0x6b50
movl %edx, (%rcx)
movl %eax, -0x4(%rbp)
leaq 0x5277(%rip), %rax      # 0x6b50
movl (%rax), %eax
movl %eax, %edx
addl $0x1, %edx
leaq 0x5269(%rip), %rcx      # 0x6b50
movl %edx, (%rcx)
movl %eax, -0x8(%rbp)
movl $0xe, %edi
callq 0x1490
callq 0x1fd0
movl %eax, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
je 0x194b
leaq 0x4795(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x27b9(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
leaq 0x281b(%rip), %rdi      # 0x413d
movb $0x0, %al
callq 0x1080
leaq 0x48b4(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x48a8(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x489b(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
cmpl $0x0, 0x520e(%rip)      # 0x6b60
je 0x196e
movq 0x51fd(%rip), %rdi      # 0x6b58
movl -0x4(%rbp), %edx
leaq 0x2817(%rip), %rsi      # 0x417c
movb $0x0, %al
callq 0x10b0
jmp 0x1986
movq 0x51e3(%rip), %rdi      # 0x6b58
movl -0x4(%rbp), %edx
leaq 0x280f(%rip), %rsi      # 0x418e
movb $0x0, %al
callq 0x10b0
movl $0xf, %edi
callq 0x1490
callq 0x17c0
movq 0x51bc(%rip), %rdi      # 0x6b58
movl -0x8(%rbp), %edx
leaq 0x27fa(%rip), %rsi      # 0x41a0
movb $0x0, %al
callq 0x10b0
movl $0x10, %edi
callq 0x1490
movq 0x519a(%rip), %rdi      # 0x6b58
movl -0x4(%rbp), %edx
leaq 0x27e4(%rip), %rsi      # 0x41ac
movb $0x0, %al
callq 0x10b0
callq 0x17c0
movq 0x517d(%rip), %rdi      # 0x6b58
movl -0x8(%rbp), %edx
leaq 0x27c7(%rip), %rsi      # 0x41ac
movb $0x0, %al
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: while_stmt
void while_stmt(void)
{
    int loop_etiq = NEXT_ETIQ, end_etiq = NEXT_ETIQ;
    accepter(WHILE);
    exprType t;
    EMETTRE("etiq %d\n",loop_etiq);
    t = expr();
    if(t != Boolean) {
        ERROR_MSG("expected Boolean expression as condition for the while statement\n");
    }
    if(CONDITION_FLAG) {
        EMETTRE("aller-si-faux %d\n",end_etiq);
    } else {
        EMETTRE("aller-si-vrai %d\n",end_etiq);
    }
    accepter(DO);
    statement();
    /*inst_composee();*/
    EMETTRE("aller-a %d\n",loop_etiq);
    EMETTRE("etiq %d\n",end_etiq);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5141(%rip), %rax      # 0x6b50
movl (%rax), %eax
movl %eax, %edx
addl $0x1, %edx
leaq 0x5133(%rip), %rcx      # 0x6b50
movl %edx, (%rcx)
movl %eax, -0x4(%rbp)
leaq 0x5127(%rip), %rax      # 0x6b50
movl (%rax), %eax
movl %eax, %edx
addl $0x1, %edx
leaq 0x5119(%rip), %rcx      # 0x6b50
movl %edx, (%rcx)
movl %eax, -0x8(%rbp)
movl $0x8, %edi
callq 0x1490
movq 0x510b(%rip), %rdi      # 0x6b58
movl -0x4(%rbp), %edx
leaq 0x2755(%rip), %rsi      # 0x41ac
movb $0x0, %al
callq 0x10b0
callq 0x1fd0
movl %eax, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
je 0x1ab3
leaq 0x462d(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x2651(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
leaq 0x2871(%rip), %rdi      # 0x42fb
movb $0x0, %al
callq 0x1080
leaq 0x474c(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4740(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x4733(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
cmpl $0x0, 0x50a6(%rip)      # 0x6b60
je 0x1ad6
movq 0x5095(%rip), %rdi      # 0x6b58
movl -0x8(%rbp), %edx
leaq 0x26c1(%rip), %rsi      # 0x418e
movb $0x0, %al
callq 0x10b0
jmp 0x1aee
movq 0x507b(%rip), %rdi      # 0x6b58
movl -0x8(%rbp), %edx
leaq 0x2695(%rip), %rsi      # 0x417c
movb $0x0, %al
callq 0x10b0
movl $0x9, %edi
callq 0x1490
callq 0x17c0
movq 0x5054(%rip), %rdi      # 0x6b58
movl -0x4(%rbp), %edx
leaq 0x2692(%rip), %rsi      # 0x41a0
movb $0x0, %al
callq 0x10b0
movq 0x503c(%rip), %rdi      # 0x6b58
movl -0x8(%rbp), %edx
leaq 0x2686(%rip), %rsi      # 0x41ac
movb $0x0, %al
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: assign_stmt
void assign_stmt(void)
{
    exprType trhs, tlhs;
    int tmp;
    if (token==ID)
        if((tmp = idExists(lexeme)) == -1) {
            ERROR_MSG("variable '%s' undeclared\n", lexeme);
        }
    tlhs = idTable[tmp].type;
    EMETTRE("valeurg %s\n",lexeme);
    accepter(ID);
    accepter(ASSIGN);
    trhs = simple_expr();
    if(tlhs != trhs) {
         if(trhs != TypeError)
            ERROR_MSG("type mismatch cannot convert %s to %s\n", typeToStr(trhs), typeToStr(tlhs));
    }
    EMETTRE(":=\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x5015(%rip)      # 0x6b64
jne 0x1bb5
leaq 0x5028(%rip), %rdi      # 0x6b80
callq 0x1210
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
jne 0x1bb3
leaq 0x4534(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x2558(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
leaq 0x273e(%rip), %rdi      # 0x42c1
leaq 0x4ff6(%rip), %rsi      # 0x6b80
movb $0x0, %al
callq 0x1080
leaq 0x464c(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4640(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x4633(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
jmp 0x1bb5
movslq -0xc(%rbp), %rcx
leaq 0x4630(%rip), %rax      # 0x61f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x8(%rbp)
movq 0x4f84(%rip), %rdi      # 0x6b58
leaq 0x2762(%rip), %rsi      # 0x433d
leaq 0x4f9e(%rip), %rdx      # 0x6b80
movb $0x0, %al
callq 0x10b0
xorl %edi, %edi
callq 0x1490
movl $0x23, %edi
callq 0x1490
callq 0x21c0
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
je 0x1c72
cmpl $0x4, -0x4(%rbp)
je 0x1c27
leaq 0x4489(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x24ad(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %edi
callq 0x13c0
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %edi
callq 0x13c0
movq -0x18(%rbp), %rsi
movq %rax, %rdx
leaq 0x2601(%rip), %rdi      # 0x424a
movb $0x0, %al
callq 0x1080
leaq 0x458d(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4581(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x4574(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
movq 0x4edf(%rip), %rdi      # 0x6b58
leaq 0x26c9(%rip), %rsi      # 0x4349
movb $0x0, %al
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: read_stmt
void read_stmt(void)
{
    accepter(READ);
    accepter(LPAREN);
    if (token==ID)
        if(idExists(lexeme) == -1) {
            ERROR_MSG("variable '%s' undeclared\n", lexeme);
        }
    EMETTRE("valeurg %s\n",lexeme);
    EMETTRE("read\n");
    accepter(ID);
    accepter(RPAREN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xa, %edi
callq 0x1490
movl $0x11, %edi
callq 0x1490
cmpl $0x0, 0x4eb5(%rip)      # 0x6b64
jne 0x1d12
leaq 0x4ec8(%rip), %rdi      # 0x6b80
callq 0x1210
cmpl $-0x1, %eax
jne 0x1d10
leaq 0x43d7(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x23fb(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
leaq 0x25e1(%rip), %rdi      # 0x42c1
leaq 0x4e99(%rip), %rsi      # 0x6b80
movb $0x0, %al
callq 0x1080
leaq 0x44ef(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x44e3(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x44d6(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
jmp 0x1d12
movq 0x4e3f(%rip), %rdi      # 0x6b58
leaq 0x261d(%rip), %rsi      # 0x433d
leaq 0x4e59(%rip), %rdx      # 0x6b80
movb $0x0, %al
callq 0x10b0
movq 0x4e23(%rip), %rdi      # 0x6b58
leaq 0x2611(%rip), %rsi      # 0x434d
movb $0x0, %al
callq 0x10b0
xorl %edi, %edi
callq 0x1490
movl $0x12, %edi
callq 0x1490
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: write_stmt
void write_stmt(void)
{
    accepter(WRITE);
    accepter(LPAREN);
    if (token==ID)
        if(idExists(lexeme) == -1) {
            ERROR_MSG("variable '%s' undeclared\n", lexeme);

        }
    EMETTRE("valeurd %s\n",lexeme);
    EMETTRE("write\n");
    accepter(ID);
    accepter(RPAREN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xb, %edi
callq 0x1490
movl $0x11, %edi
callq 0x1490
cmpl $0x0, 0x4de5(%rip)      # 0x6b64
jne 0x1de2
leaq 0x4df8(%rip), %rdi      # 0x6b80
callq 0x1210
cmpl $-0x1, %eax
jne 0x1de0
leaq 0x4307(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x232b(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
leaq 0x2511(%rip), %rdi      # 0x42c1
leaq 0x4dc9(%rip), %rsi      # 0x6b80
movb $0x0, %al
callq 0x1080
leaq 0x441f(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4413(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x4406(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
jmp 0x1de2
movq 0x4d6f(%rip), %rdi      # 0x6b58
leaq 0x24c5(%rip), %rsi      # 0x42b5
leaq 0x4d89(%rip), %rdx      # 0x6b80
movb $0x0, %al
callq 0x10b0
movq 0x4d53(%rip), %rdi      # 0x6b58
leaq 0x2547(%rip), %rsi      # 0x4353
movb $0x0, %al
callq 0x10b0
xorl %edi, %edi
callq 0x1490
movl $0x12, %edi
callq 0x1490
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: readln_stmt
void readln_stmt(void)
{
    accepter(READLN);
    accepter(LPAREN);
    if (token==ID)
        if(idExists(lexeme) == -1) {
            ERROR_MSG("variable '%s' undeclared\n", lexeme);

        }
    EMETTRE("valeurg %s\n",lexeme);
    EMETTRE("readln\n");
    accepter(ID);
    accepter(RPAREN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xc, %edi
callq 0x1490
movl $0x11, %edi
callq 0x1490
cmpl $0x0, 0x4d15(%rip)      # 0x6b64
jne 0x1eb2
leaq 0x4d28(%rip), %rdi      # 0x6b80
callq 0x1210
cmpl $-0x1, %eax
jne 0x1eb0
leaq 0x4237(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x225b(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
leaq 0x2441(%rip), %rdi      # 0x42c1
leaq 0x4cf9(%rip), %rsi      # 0x6b80
movb $0x0, %al
callq 0x1080
leaq 0x434f(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4343(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x4336(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
jmp 0x1eb2
movq 0x4c9f(%rip), %rdi      # 0x6b58
leaq 0x247d(%rip), %rsi      # 0x433d
leaq 0x4cb9(%rip), %rdx      # 0x6b80
movb $0x0, %al
callq 0x10b0
movq 0x4c83(%rip), %rdi      # 0x6b58
leaq 0x247e(%rip), %rsi      # 0x435a
movb $0x0, %al
callq 0x10b0
xorl %edi, %edi
callq 0x1490
movl $0x12, %edi
callq 0x1490
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/parse.c
// Function: writeln_stmt
void writeln_stmt(void)
{
    accepter(WRITELN);
    accepter(LPAREN);
    if (token==ID)
    if(idExists(lexeme) == -1) {
        ERROR_MSG("variable '%s' undeclared\n", lexeme);
    }
    EMETTRE("valeurd %s\n",lexeme);
    EMETTRE("writeln\n");

    accepter(ID);
    accepter(RPAREN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xd, %edi
callq 0x1490
movl $0x11, %edi
callq 0x1490
cmpl $0x0, 0x4c45(%rip)      # 0x6b64
jne 0x1f82
leaq 0x4c58(%rip), %rdi      # 0x6b80
callq 0x1210
cmpl $-0x1, %eax
jne 0x1f80
leaq 0x4167(%rip), %rax      # 0x60a0
movl (%rax), %esi
leaq 0x218b(%rip), %rdi      # 0x40cd
movb $0x0, %al
callq 0x1080
leaq 0x2371(%rip), %rdi      # 0x42c1
leaq 0x4c29(%rip), %rsi      # 0x6b80
movb $0x0, %al
callq 0x1080
leaq 0x427f(%rip), %rax      # 0x61e4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4273(%rip), %rax      # 0x61e4
movl %ecx, (%rax)
leaq 0x4266(%rip), %rax      # 0x61e0
movl $0x1, (%rax)
jmp 0x1f82
movq 0x4bcf(%rip), %rdi      # 0x6b58
leaq 0x2325(%rip), %rsi      # 0x42b5
leaq 0x4be9(%rip), %rdx      # 0x6b80
movb $0x0, %al
callq 0x10b0
movq 0x4bb3(%rip), %rdi      # 0x6b58
leaq 0x23b6(%rip), %rsi      # 0x4362
movb $0x0, %al
callq 0x10b0
xorl %edi, %edi
callq 0x1490
movl $0x12, %edi
callq 0x1490
popq %rbp
retq
nopw %cs:(%rax,%rax)