LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_20/detab.c
// Function: main
int main(void)
{
  int c;
  unsigned int nr_of_spaces;

  while ((c = getchar()) != EOF)
  {
    if (c == '\t')
    {
      nr_of_spaces = TAB_LENGTH;

      while (nr_of_spaces)
      {
        putchar(' ');
        --nr_of_spaces;
      }
    }
    else
    {
      putchar(c);
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1040
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x11a0
cmpl $0x9, -0x8(%rbp)
jne 0x1196
movl $0x8, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1194
movl $0x20, %edi
callq 0x1030
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1179
jmp 0x119e
movl -0x8(%rbp), %edi
callq 0x1030
jmp 0x115f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/preload/run/run.c
// Function: fiu_run_init
static void __attribute__((constructor)) fiu_run_init(void)
{
	char *fiu_fifo_env, *fiu_enable_env;

	fiu_init(0);

	fiu_fifo_env = getenv("FIU_CTRL_FIFO");
	if (fiu_fifo_env && *fiu_fifo_env != '\0') {
		if (fiu_rc_fifo(fiu_fifo_env) < 0) {
			perror("fiu_run_preload: Error opening RC fifo");
		}
	}

	fiu_enable_env = getenv("FIU_ENABLE");
	if (fiu_enable_env && *fiu_enable_env != '\0') {
		/* FIU_ENABLE can contain more than one command, separated by
		 * a newline, so we split them and call fiu_rc_string()
		 * accordingly. */
		char *tok, *state;
		char *env_copy;
		char *rc_error = "no error returned";

		env_copy = strdup(fiu_enable_env);
		if (env_copy == NULL) {
			perror("fiu_run_preload: Error in strdup()");
			return;
		}

		tok = strtok_r(env_copy, "\n", &state);
		while (tok) {
			if (fiu_rc_string(tok, &rc_error) != 0) {
				fprintf(stderr,
				        "fiu_run_preload: Error applying "
				        "FIU_ENABLE commands: %s\n",
				        rc_error);
				return;
			}
			tok = strtok_r(NULL, "\n", &state);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %edi, %edi
callq 0x1040
leaq 0xe6a(%rip), %rdi       # 0x2000
callq 0x1030
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11ce
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11ce
movq -0x8(%rbp), %rdi
callq 0x1050
cmpl $0x0, %eax
jge 0x11cc
leaq 0xe47(%rip), %rdi       # 0x200e
callq 0x1090
jmp 0x11ce
leaq 0xe60(%rip), %rdi       # 0x2035
callq 0x1030
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1291
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1291
leaq 0xe40(%rip), %rax       # 0x2040
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1226
leaq 0xe33(%rip), %rdi       # 0x2052
callq 0x1090
jmp 0x1291
movq -0x28(%rbp), %rdi
leaq 0xe7b(%rip), %rsi       # 0x20ac
leaq -0x20(%rbp), %rdx
callq 0x1060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x128f
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1080
cmpl $0x0, %eax
je 0x1275
movq 0x2d9a(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
leaq 0xe09(%rip), %rsi       # 0x2075
movb $0x0, %al
callq 0x1070
jmp 0x1291
xorl %eax, %eax
movl %eax, %edi
leaq 0xe2c(%rip), %rsi       # 0x20ac
leaq -0x20(%rbp), %rdx
callq 0x1060
movq %rax, -0x18(%rbp)
jmp 0x123e
jmp 0x1291
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv3/aesni/aez_ni.c
// Function: load_partial
static __m128i load_partial(const void *p, unsigned n) {
    if ((unsigned long)p % 16 == 0) return _mm_loadu_si128((__m128i*)p);
    else {
        __m128i tmp; unsigned i;
        for (i=0; i<n; i++) ((char*)&tmp)[i] = ((char*)p)[i];
        return tmp;
    }
}

// Assembly:
movq %rdi, -0x20(%rsp)
movl %esi, -0x24(%rsp)
movq -0x20(%rsp), %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x28a3
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, -0x18(%rsp)
jmp 0x28e2
movl $0x0, -0x3c(%rsp)
movl -0x3c(%rsp), %eax
cmpl -0x24(%rsp), %eax
jae 0x28d6
movq -0x20(%rsp), %rax
movl -0x3c(%rsp), %ecx
movb (%rax,%rcx), %cl
movl -0x3c(%rsp), %eax
movb %cl, -0x38(%rsp,%rax)
movl -0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rsp)
jmp 0x28ab
vmovdqa -0x38(%rsp), %xmm0
vmovdqa %xmm0, -0x18(%rsp)
vmovdqa -0x18(%rsp), %xmm0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv3/aesni/aez_ni.c
// Function: aes
static __m128i aes(__m128i *key, __m128i in) {
    in = _mm_aesenc_si128 (in,key[0]);
    in = _mm_aesenc_si128 (in,key[1]);
    in = _mm_aesenc_si128 (in,key[2]);
    in = _mm_aesenc_si128 (in,key[0]);
    in = _mm_aesenc_si128 (in,key[1]);
    in = _mm_aesenc_si128 (in,key[2]);
    in = _mm_aesenc_si128 (in,key[0]);
    in = _mm_aesenc_si128 (in,key[1]);
    in = _mm_aesenc_si128 (in,key[2]);
    return _mm_aesenc_si128 (in,key[0]);
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, -0x68(%rsp)
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0xd0(%rsp)
vmovdqa %xmm0, 0xc0(%rsp)
vmovdqa 0xd0(%rsp), %xmm0
vmovdqa 0xc0(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa 0x10(%rax), %xmm0
vmovdqa %xmm1, 0xb0(%rsp)
vmovdqa %xmm0, 0xa0(%rsp)
vmovdqa 0xb0(%rsp), %xmm0
vmovdqa 0xa0(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa 0x20(%rax), %xmm0
vmovdqa %xmm1, 0x90(%rsp)
vmovdqa %xmm0, 0x80(%rsp)
vmovdqa 0x90(%rsp), %xmm0
vmovdqa 0x80(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x70(%rsp)
vmovdqa %xmm0, 0x60(%rsp)
vmovdqa 0x70(%rsp), %xmm0
vmovdqa 0x60(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa 0x10(%rax), %xmm0
vmovdqa %xmm1, 0x50(%rsp)
vmovdqa %xmm0, 0x40(%rsp)
vmovdqa 0x50(%rsp), %xmm0
vmovdqa 0x40(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa 0x20(%rax), %xmm0
vmovdqa %xmm1, 0x30(%rsp)
vmovdqa %xmm0, 0x20(%rsp)
vmovdqa 0x30(%rsp), %xmm0
vmovdqa 0x20(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x10(%rsp)
vmovdqa %xmm0, (%rsp)
vmovdqa 0x10(%rsp), %xmm0
vmovdqa (%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa 0x10(%rax), %xmm0
vmovdqa %xmm1, -0x10(%rsp)
vmovdqa %xmm0, -0x20(%rsp)
vmovdqa -0x10(%rsp), %xmm0
vmovdqa -0x20(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa 0x20(%rax), %xmm0
vmovdqa %xmm1, -0x30(%rsp)
vmovdqa %xmm0, -0x40(%rsp)
vmovdqa -0x30(%rsp), %xmm0
vmovdqa -0x40(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, -0x50(%rsp)
vmovdqa %xmm0, -0x60(%rsp)
vmovdqa -0x50(%rsp), %xmm0
vmovdqa -0x60(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
addq $0xe8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv3/aesni/aez_ni.c
// Function: aez_encrypt
void aez_encrypt(aez_ctx_t *ctx, char *n, unsigned nbytes,
                 char *ad, unsigned adbytes, unsigned abytes,
                 char *src, unsigned bytes, char *dst) {

    __m128i t = aez_hash(ctx, n, nbytes, ad, adbytes, abytes);
    if (bytes==0) {
        unsigned i;
        t = aes((__m128i*)ctx, vxor3(t, ctx->J[0], ctx->J[1]));
        for (i=0; i<abytes; i++) dst[i] = ((char*)&t)[i];
    } else if (bytes+abytes < 32)
        cipher_aez_tiny(ctx, t, 0, src, bytes, abytes, dst);
    else
        cipher_aez_core(ctx, t, 0, src, bytes, abytes, dst);
}

// Assembly:
subq $0x98, %rsp
movq 0xb0(%rsp), %rax
movl 0xa8(%rsp), %eax
movq 0xa0(%rsp), %rax
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq %rcx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movl %r9d, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl 0x3c(%rsp), %edx
movq 0x30(%rsp), %rcx
movl 0x2c(%rsp), %r8d
movl 0x28(%rsp), %r9d
callq 0x1080
vmovdqa %xmm0, 0x10(%rsp)
cmpl $0x0, 0xa8(%rsp)
jne 0xae39
movq 0x48(%rsp), %rdi
vmovdqa 0x10(%rsp), %xmm1
movq 0x48(%rsp), %rax
vmovdqa 0x20(%rax), %xmm0
vmovdqa %xmm1, 0x80(%rsp)
vmovdqa %xmm0, 0x70(%rsp)
vmovdqa 0x80(%rsp), %xmm0
vpxor 0x70(%rsp), %xmm0, %xmm1
movq 0x48(%rsp), %rax
vmovdqa 0x30(%rax), %xmm0
vmovdqa %xmm1, 0x60(%rsp)
vmovdqa %xmm0, 0x50(%rsp)
vmovdqa 0x60(%rsp), %xmm0
vpxor 0x50(%rsp), %xmm0, %xmm0
callq 0x9be0
vmovdqa %xmm0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x28(%rsp), %eax
jae 0xae37
movl 0xc(%rsp), %eax
movb 0x10(%rsp,%rax), %dl
movq 0xb0(%rsp), %rax
movl 0xc(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xae09
jmp 0xaea9
movl 0xa8(%rsp), %eax
addl 0x28(%rsp), %eax
cmpl $0x20, %eax
jae 0xae79
movq 0x48(%rsp), %rdi
vmovdqa 0x10(%rsp), %xmm0
movq 0xa0(%rsp), %rdx
movl 0xa8(%rsp), %ecx
movl 0x28(%rsp), %r8d
movq 0xb0(%rsp), %r9
xorl %esi, %esi
callq 0x1040
jmp 0xaea7
movq 0x48(%rsp), %rdi
vmovdqa 0x10(%rsp), %xmm0
movq 0xa0(%rsp), %rdx
movl 0xa8(%rsp), %ecx
movl 0x28(%rsp), %r8d
movq 0xb0(%rsp), %r9
xorl %esi, %esi
callq 0x10c0
jmp 0xaea9
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv3/aesni/aez_ni.c
// Function: aez_decrypt
int aez_decrypt(aez_ctx_t *ctx, char *n, unsigned nbytes,
                 char *ad, unsigned adbytes, unsigned abytes,
                 char *src, unsigned bytes, char *dst) {

    __m128i t;
    if (bytes < abytes) return -1;
    t = aez_hash(ctx, n, nbytes, ad, adbytes, abytes);
    if (bytes==abytes) {
        __m128i claimed = zero_pad(load_partial(src,abytes), 16-abytes);
        t = zero_pad(aes((__m128i*)ctx, vxor3(t, ctx->J[0], ctx->J[1])), 16-abytes);
        return _mm_testc_si128(t, claimed) - 1;
    } else if (bytes < 32) {
        return cipher_aez_tiny(ctx, t, 1, src, bytes, abytes, dst);
    } else {
        return cipher_aez_core(ctx, t, 1, src, bytes, abytes, dst);
    }
}

// Assembly:
subq $0xb8, %rsp
movq 0xd0(%rsp), %rax
movl 0xc8(%rsp), %eax
movq 0xc0(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movl %r9d, 0x20(%rsp)
movl 0xc8(%rsp), %eax
cmpl 0x20(%rsp), %eax
jae 0xaf15
movl $0xffffffff, 0x4c(%rsp) # imm = 0xFFFFFFFF
jmp 0xb099
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x28(%rsp), %rcx
movl 0x24(%rsp), %r8d
movl 0x20(%rsp), %r9d
callq 0x1080
vmovdqa %xmm0, 0x10(%rsp)
movl 0xc8(%rsp), %eax
cmpl 0x20(%rsp), %eax
jne 0xb023
movq 0xc0(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x2870
movl $0x10, %edi
subl 0x20(%rsp), %edi
callq 0x9b90
vmovdqa %xmm0, (%rsp)
movq 0x40(%rsp), %rdi
vmovdqa 0x10(%rsp), %xmm1
movq 0x40(%rsp), %rax
vmovdqa 0x20(%rax), %xmm0
vmovdqa %xmm1, 0x80(%rsp)
vmovdqa %xmm0, 0x70(%rsp)
vmovdqa 0x80(%rsp), %xmm0
vpxor 0x70(%rsp), %xmm0, %xmm1
movq 0x40(%rsp), %rax
vmovdqa 0x30(%rax), %xmm0
vmovdqa %xmm1, 0x60(%rsp)
vmovdqa %xmm0, 0x50(%rsp)
vmovdqa 0x60(%rsp), %xmm0
vpxor 0x50(%rsp), %xmm0, %xmm0
callq 0x9be0
movl $0x10, %edi
subl 0x20(%rsp), %edi
callq 0x9b90
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x10(%rsp), %xmm1
vmovdqa (%rsp), %xmm0
vmovdqa %xmm1, 0xa0(%rsp)
vmovdqa %xmm0, 0x90(%rsp)
vmovdqa 0xa0(%rsp), %xmm0
vmovdqa 0x90(%rsp), %xmm1
vptest %xmm1, %xmm0
setb %al
movzbl %al, %eax
subl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0xb099
cmpl $0x20, 0xc8(%rsp)
jae 0xb064
movq 0x40(%rsp), %rdi
vmovdqa 0x10(%rsp), %xmm0
movq 0xc0(%rsp), %rdx
movl 0xc8(%rsp), %ecx
movl 0x20(%rsp), %r8d
movq 0xd0(%rsp), %r9
movl $0x1, %esi
callq 0x1040
movl %eax, 0x4c(%rsp)
jmp 0xb099
movq 0x40(%rsp), %rdi
vmovdqa 0x10(%rsp), %xmm0
movq 0xc0(%rsp), %rdx
movl 0xc8(%rsp), %ecx
movl 0x20(%rsp), %r8d
movq 0xd0(%rsp), %r9
movl $0x1, %esi
callq 0x10c0
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_plain.c
// Function: main
int
main(int argc, char *argv[])
{
	FILE *fp;
	char *name;
	int i;

	if (pledge("stdio rpath", NULL) == -1)
		err(1, "pledge");

	setlocale(LC_CTYPE, "");

	if (pledge(argc == 1 ? "stdio" : "stdio rpath", NULL) == -1)
		err(1, "pledge");

	if ((comparetime = time(NULL)) == -1)
		err(1, "time");
	/* 1 day is old news */
	comparetime -= 86400;

	if (argc == 1) {
		printfeed(stdin, "");
	} else {
		for (i = 1; i < argc; i++) {
			if (!(fp = fopen(argv[i], "r")))
				err(1, "fopen: %s", argv[i]);
			name = ((name = strrchr(argv[i], '/'))) ? name + 1 : argv[i];
			printfeed(fp, name);
			if (ferror(fp))
				err(1, "ferror: %s", argv[i]);
			fclose(fp);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %edi, %edi
leaq 0x1d38(%rip), %rsi      # 0x3047
callq 0x1190
xorl %eax, %eax
movl %eax, %edi
callq 0x1160
movq %rax, 0x3df4(%rip)      # 0x5118
cmpq $-0x1, %rax
jne 0x133d
movl $0x1, %edi
leaq 0x1cea(%rip), %rsi      # 0x3020
movb $0x0, %al
callq 0x1180
movq 0x3dd4(%rip), %rax      # 0x5118
subq $0x15180, %rax          # imm = 0x15180
movq %rax, 0x3dc7(%rip)      # 0x5118
cmpl $0x1, -0x8(%rbp)
jne 0x1372
movq 0x3c82(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1cdf(%rip), %rsi      # 0x3047
callq 0x1470
jmp 0x145f
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x145d
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x1c6c(%rip), %rsi      # 0x3004
callq 0x11a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x13c6
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl $0x1, %edi
leaq 0x1c47(%rip), %rsi      # 0x3006
movb $0x0, %al
callq 0x1180
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x2f, %esi
callq 0x10c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x13f4
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1404
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1470
movq -0x18(%rbp), %rdi
callq 0x1060
cmpl $0x0, %eax
je 0x1446
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl $0x1, %edi
leaq 0x1bd1(%rip), %rsi      # 0x3010
movb $0x0, %al
callq 0x1180
movq -0x18(%rbp), %rdi
callq 0x1070
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1379
jmp 0x145f
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_plain.c
// Function: printfeed
static void
printfeed(FILE *fp, const char *feedname)
{
	char *fields[FieldLast];
	struct tm *tm;
	time_t parsedtime;
	ssize_t linelen;

	while ((linelen = getline(&line, &linesize, fp)) > 0) {
		if (line[linelen - 1] == '\n')
			line[--linelen] = '\0';
		if (!parseline(line, fields))
			break;

		parsedtime = 0;
		if (strtotime(fields[FieldUnixTimestamp], &parsedtime))
			continue;
		if (!(tm = localtime(&parsedtime)))
			err(1, "localtime");

		if (parsedtime >= comparetime)
			fputs("N ", stdout);
		else
			fputs("  ", stdout);

		fprintf(stdout, "%04d-%02d-%02d %02d:%02d  ",
		        tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
		        tm->tm_hour, tm->tm_min);
		if (feedname[0]) {
			printutf8pad(stdout, feedname, 15, ' ');
			fputs("  ", stdout);
		}
		printutf8pad(stdout, fields[FieldTitle], 70, ' ');
		printf(" %s\n", fields[FieldLink]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x3c95(%rip), %rdi      # 0x5120
leaq 0x3c96(%rip), %rsi      # 0x5128
callq 0x11c0
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
jle 0x162c
movq 0x3c74(%rip), %rax      # 0x5120
movq -0x68(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x14d8
movq 0x3c5c(%rip), %rax      # 0x5120
movq -0x68(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x68(%rbp)
movb $0x0, -0x1(%rax,%rcx)
movq 0x3c41(%rip), %rdi      # 0x5120
leaq -0x50(%rbp), %rsi
callq 0x1f90
cmpq $0x0, %rax
jne 0x14f3
jmp 0x162c
movq $0x0, -0x60(%rbp)
movq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2070
cmpl $0x0, %eax
je 0x1512
jmp 0x1480
leaq -0x60(%rbp), %rdi
callq 0x1030
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
jne 0x1538
movl $0x1, %edi
leaq 0x1aea(%rip), %rsi      # 0x301b
movb $0x0, %al
callq 0x1180
movq -0x60(%rbp), %rax
cmpq 0x3bd5(%rip), %rax      # 0x5118
jl 0x155d
movq 0x3a8c(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1acf(%rip), %rdi      # 0x3025
callq 0x10d0
jmp 0x1573
movq 0x3a74(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1ad2(%rip), %rdi      # 0x3040
callq 0x10d0
movq 0x3a5e(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
movq -0x58(%rbp), %rax
movl 0x14(%rax), %edx
addl $0x76c, %edx            # imm = 0x76C
movq -0x58(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movq -0x58(%rbp), %rax
movl 0xc(%rax), %r8d
movq -0x58(%rbp), %rax
movl 0x8(%rax), %r9d
movq -0x58(%rbp), %rax
movl 0x4(%rax), %eax
leaq 0x1a76(%rip), %rsi      # 0x3028
movl %eax, (%rsp)
movb $0x0, %al
callq 0x1130
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x15f8
movq 0x3a0c(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0xf, %edx
movl $0x20, %ecx
callq 0x21c0
movq 0x39ef(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1a4d(%rip), %rdi      # 0x3040
callq 0x10d0
movq 0x39d9(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
movq -0x48(%rbp), %rsi
movl $0x46, %edx
movl $0x20, %ecx
callq 0x21c0
movq -0x40(%rbp), %rsi
leaq 0x1a23(%rip), %rdi      # 0x3043
movb $0x0, %al
callq 0x10a0
jmp 0x1480
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/open3.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	while (1) {
		int fd = open(tmpfile, O_RDWR);
		assert(fd >= 0);
		close(fd);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x30e9(%rip), %rdi      # 0x5180
movl $0x2, %esi
movb $0x0, %al
callq 0x1210
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x20ae
jmp 0x20cd
leaq 0x11b8(%rip), %rdi      # 0x326d
leaq 0x11b9(%rip), %rsi      # 0x3275
movl $0x18, %edx
leaq 0x11e0(%rip), %rcx      # 0x32a8
callq 0x1120
movl -0x14(%rbp), %edi
callq 0x1150
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2090
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/info-telecom-strasbourg[P]code-generator/src/flag_m.cpp
// Function: create_standard_include(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void create_standard_include (string file_name, string include_path) {
	int exit_code;
	vector<char*> cmd;

	LOAD_CMD ("bash");
	LOAD_CMD (ADD_HEADER_SCRIPT_PATH);
	LOAD_CMD ("0");
	LOAD_CMD (file_name.c_str());
	LOAD_CMD (include_path.c_str());

	cout << execute (exit_code, BASH_PATH, cmd);
	if (exit_code)
		return;

	cout << "\033[1;32minfo\033[0m: created standard header " 
		<< file_name << ".\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rsi, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4d90
leaq 0x6548(%rip), %rax      # 0xa0f9
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4db0
jmp 0x3bc4
jmp 0x3bc6
jmp 0x3bc8
jmp 0x3bca
leaq 0x6597(%rip), %rax      # 0xa168
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4db0
jmp 0x3be4
jmp 0x3be6
jmp 0x3be8
jmp 0x3bea
leaq 0x65a3(%rip), %rax      # 0xa194
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4db0
jmp 0x3c04
jmp 0x3c06
jmp 0x3c08
jmp 0x3c0a
movq -0xb8(%rbp), %rdi
callq 0x30c0
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4db0
jmp 0x3c29
jmp 0x3c2b
jmp 0x3c2d
jmp 0x3c2f
movq -0xb0(%rbp), %rdi
callq 0x30c0
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4db0
jmp 0x3c4e
jmp 0x3c50
jmp 0x3c52
leaq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4e10
jmp 0x3c64
leaq 0x6485(%rip), %rdx      # 0xa0f0
leaq -0x88(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0xa0(%rbp), %rcx
callq 0x8780
jmp 0x3c84
movq 0xa33d(%rip), %rdi      # 0xdfc8
leaq -0x88(%rbp), %rsi
callq 0x3200
jmp 0x3c99
leaq -0x88(%rbp), %rdi
callq 0x3140
leaq -0xa0(%rbp), %rdi
callq 0x4f00
cmpl $0x0, -0x14(%rbp)
je 0x3d0b
movl $0x1, -0xa4(%rbp)
jmp 0x3d62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3d74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3cfd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3140
leaq -0xa0(%rbp), %rdi
callq 0x4f00
jmp 0x3d74
movq 0xa2b6(%rip), %rdi      # 0xdfc8
leaq 0x647d(%rip), %rsi      # 0xa196
callq 0x3230
movq %rax, -0xc0(%rbp)
jmp 0x3d27
movq -0xb8(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x3200
movq %rax, -0xc8(%rbp)
jmp 0x3d43
movq -0xc8(%rbp), %rdi
leaq 0x64dc(%rip), %rsi      # 0xa22d
callq 0x3230
jmp 0x3d58
movl $0x0, -0xa4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4f00
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x4f00
movq -0x40(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/info-telecom-strasbourg[P]code-generator/src/flag_m.cpp
// Function: create_dir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void create_dir (string path) {
    if (mkdir(path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0) {
        cout << "\033[1;32minfo\033[0m: directory \""<< path
			<< "\" wasn't created. It must already exist.\n";
    } else {
		cout << "\033[1;32minfo\033[0m: created directory \"" << path
			<< "\".\n";
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x30c0
movq %rax, %rdi
movl $0x1fd, %esi            # imm = 0x1FD
callq 0x3100
cmpl $0x0, %eax
je 0x3de7
movq 0xa20a(%rip), %rdi      # 0xdfc8
leaq 0x63fb(%rip), %rsi      # 0xa1c0
callq 0x3230
movq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
leaq 0x63fd(%rip), %rsi      # 0xa1dd
callq 0x3230
jmp 0x3e15
movq 0xa1da(%rip), %rdi      # 0xdfc8
leaq 0x6412(%rip), %rsi      # 0xa207
callq 0x3230
movq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
leaq 0x641c(%rip), %rsi      # 0xa22c
callq 0x3230
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/info-telecom-strasbourg[P]code-generator/src/other_flags.cpp
// Function: flag_t(char*)
void flag_t (char * optarg_) {
	int exit_code;
	vector<char*> cmd;

	LOAD_CMD ("bash");
	LOAD_CMD (LOAD_TEMPLATE_SCRIPT_PATH);
	LOAD_CMD (optarg_);
	LOAD_CMD (LOAD_TEMPLATES_DIR_PATH);

	cout << execute (exit_code, BASH_PATH, cmd);
	CHECK_CODE (exit_code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4d90
leaq 0x3ada(%rip), %rax      # 0xa0f9
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4db0
jmp 0x6632
jmp 0x6634
jmp 0x6636
jmp 0x6638
leaq 0x3eb9(%rip), %rax      # 0xa4f8
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4db0
jmp 0x6652
jmp 0x6654
jmp 0x6656
jmp 0x6658
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4db0
jmp 0x666f
jmp 0x6671
jmp 0x6673
jmp 0x6675
leaq 0x3eab(%rip), %rax      # 0xa527
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4db0
jmp 0x668f
jmp 0x6691
jmp 0x6693
leaq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4e10
jmp 0x66a5
leaq 0x3a44(%rip), %rdx      # 0xa0f0
leaq -0x78(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x90(%rbp), %rcx
callq 0x8780
jmp 0x66c2
movq 0x78ff(%rip), %rdi      # 0xdfc8
leaq -0x78(%rbp), %rsi
callq 0x3200
jmp 0x66d4
leaq -0x78(%rbp), %rdi
callq 0x3140
leaq -0x90(%rbp), %rdi
callq 0x4f00
cmpl $0x1, -0xc(%rbp)
jne 0x6738
movl $0x1, %edi
callq 0x3310
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x674e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x672a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3140
leaq -0x90(%rbp), %rdi
callq 0x4f00
jmp 0x674e
jmp 0x673a
jmp 0x673c
leaq -0x28(%rbp), %rdi
callq 0x4f00
addq $0x90, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x4f00
movq -0x38(%rbp), %rdi
callq 0x3490
// File: /workspace/github_c_makefile_star2_O0/info-telecom-strasbourg[P]code-generator/src/other_flags.cpp
// Function: flag_c()
void flag_c () {
	int exit_code;
	vector<char*> cmd;

	LOAD_CMD ("bash");
	LOAD_CMD (CPY_FILES_SCRIPT_PATH);
	LOAD_CMD (BLANK_CONFIG_FILE_PATH);
	LOAD_CMD (".");

	cout << execute (exit_code, BASH_PATH, cmd);
	CHECK_CODE (exit_code);

	cout << "\033[1;32minfo\033[0m: added codegen_config.txt to the"
		<< " directory.\n";  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x20(%rbp), %rdi
callq 0x4d90
leaq 0x29fe(%rip), %rax      # 0xa0f9
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4db0
jmp 0x770e
jmp 0x7710
jmp 0x7712
jmp 0x7714
leaq 0x28e9(%rip), %rax      # 0xa004
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4db0
jmp 0x772e
jmp 0x7730
jmp 0x7732
jmp 0x7734
leaq 0x2f29(%rip), %rax      # 0xa664
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4db0
jmp 0x774e
jmp 0x7750
jmp 0x7752
jmp 0x7754
leaq 0x31e9(%rip), %rax      # 0xa944
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4db0
jmp 0x776e
jmp 0x7770
jmp 0x7772
leaq -0x88(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4e10
jmp 0x7784
leaq 0x2965(%rip), %rdx      # 0xa0f0
leaq -0x70(%rbp), %rdi
leaq -0x4(%rbp), %rsi
leaq -0x88(%rbp), %rcx
callq 0x8780
jmp 0x77a1
movq 0x6820(%rip), %rdi      # 0xdfc8
leaq -0x70(%rbp), %rsi
callq 0x3200
jmp 0x77b3
leaq -0x70(%rbp), %rdi
callq 0x3140
leaq -0x88(%rbp), %rdi
callq 0x4f00
cmpl $0x1, -0x4(%rbp)
jne 0x7817
movl $0x1, %edi
callq 0x3310
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x785e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x7809
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3140
leaq -0x88(%rbp), %rdi
callq 0x4f00
jmp 0x785e
jmp 0x7819
jmp 0x781b
movq 0x67a6(%rip), %rdi      # 0xdfc8
leaq 0x2e69(%rip), %rsi      # 0xa692
callq 0x3230
movq %rax, -0x90(%rbp)
jmp 0x7837
movq -0x90(%rbp), %rdi
leaq 0x2e7e(%rip), %rsi      # 0xa6c3
callq 0x3230
jmp 0x784c
leaq -0x20(%rbp), %rdi
callq 0x4f00
addq $0x90, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x4f00
movq -0x30(%rbp), %rdi
callq 0x3490
// File: /workspace/github_c_makefile_star2_O0/info-telecom-strasbourg[P]code-generator/src/other_flags.cpp
// Function: flag_d()
void flag_d () {
	int exit_code;
	vector<char*> cmd;

	LOAD_CMD ("rm");
	LOAD_CMD ("codegen_config.txt");
	LOAD_CMD (".codegen_config_bin");

	cout << execute (exit_code, RM_PATH, cmd);
	CHECK_CODE (exit_code);

	cout << "\033[1;32minfo\033[0m: removed all codegen setup files.\n";  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x20(%rbp), %rdi
callq 0x4d90
leaq 0x2e4e(%rip), %rax      # 0xa6d9
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4db0
jmp 0x789e
jmp 0x78a0
jmp 0x78a2
jmp 0x78a4
leaq 0x2dd4(%rip), %rax      # 0xa67f
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4db0
jmp 0x78be
jmp 0x78c0
jmp 0x78c2
jmp 0x78c4
leaq 0x29e9(%rip), %rax      # 0xa2b4
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4db0
jmp 0x78de
jmp 0x78e0
jmp 0x78e2
leaq -0x80(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4e10
jmp 0x78f1
leaq 0x2dd8(%rip), %rdx      # 0xa6d0
leaq -0x68(%rbp), %rdi
leaq -0x4(%rbp), %rsi
leaq -0x80(%rbp), %rcx
callq 0x8780
jmp 0x790b
movq 0x66b6(%rip), %rdi      # 0xdfc8
leaq -0x68(%rbp), %rsi
callq 0x3200
jmp 0x791d
leaq -0x68(%rbp), %rdi
callq 0x3140
leaq -0x80(%rbp), %rdi
callq 0x4f00
cmpl $0x1, -0x4(%rbp)
jne 0x797b
movl $0x1, %edi
callq 0x3310
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x79a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x7970
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3140
leaq -0x80(%rbp), %rdi
callq 0x4f00
jmp 0x79a6
jmp 0x797d
jmp 0x797f
movq 0x6642(%rip), %rdi      # 0xdfc8
leaq 0x2d4f(%rip), %rsi      # 0xa6dc
callq 0x3230
jmp 0x7994
leaq -0x20(%rbp), %rdi
callq 0x4f00
addq $0x80, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x4f00
movq -0x30(%rbp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/info-telecom-strasbourg[P]code-generator/src/utils.cpp
// Function: interupt(int, char const*, ...)
void interupt(int syserr, const char * msg, ...) {
	va_list ap;

	va_start(ap, msg);
	vfprintf(stderr, msg, ap);
	fprintf (stderr, "\n");
	va_end(ap);

	if (syserr == 1)
		perror("");

	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x81c8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x5dba(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3390
movq 0x5da3(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x242b(%rip), %rsi      # 0xa662
movb $0x0, %al
callq 0x33e0
leaq -0x30(%rbp), %rax
cmpl $0x1, -0x4(%rbp)
jne 0x8254
leaq 0x2414(%rip), %rdi      # 0xa663
callq 0x31b0
movl $0x1, %edi
callq 0x3310
nop
// File: /workspace/github_c_makefile_star2_O0/info-telecom-strasbourg[P]code-generator/src/utils.cpp
// Function: has_dot(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool has_dot (string token) {
	for (auto & c : token) {
		if ( c == '.' )
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3120
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8f30
testb $0x1, %al
jne 0x82cd
jmp 0x82f9
leaq -0x20(%rbp), %rdi
callq 0x8f70
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x82ec
movb $0x1, -0x1(%rbp)
jmp 0x82fd
jmp 0x82ee
leaq -0x20(%rbp), %rdi
callq 0x8f90
jmp 0x82ba
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/info-telecom-strasbourg[P]code-generator/src/utils.cpp
// Function: execute[abi:cxx11](int&, char const*, std::vector<char*, std::allocator<char*>>)
string execute (int & exit_code, const char * path, vector<char*> cmd) {

	cmd.push_back(NULL);

  	char **cmd_ptr = cmd.data();

	size_t len;

	string output = __execute__ (&exit_code, &len, path, cmd_ptr);

	output [len - 1] = '\0';

	return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rcx, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq %rax, %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x4db0
movq -0x68(%rbp), %rdi
callq 0x8fb0
movq -0x60(%rbp), %rdi
movq %rax, -0x30(%rbp)
movb $0x0, -0x39(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq -0x38(%rbp), %rdx
callq 0x8310
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
decq %rsi
callq 0x3510
movq %rax, -0x58(%rbp)
jmp 0x87ff
movq -0x58(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x8832
jmp 0x8829
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3140
jmp 0x883c
movq -0x60(%rbp), %rdi
callq 0x3140
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/info-telecom-strasbourg[P]code-generator/src/utils.cpp
// Function: s_execute[abi:cxx11](int&, char const*, char const*)
string s_execute (int & exit_code, const char * path, const char * s) {
	
	vector<char*> cmd;

	cmd.push_back (const_cast<char*>(s));

	cmd.push_back(NULL);

  	char **cmd_ptr = cmd.data();

	size_t len;

	string output = __execute__ (&exit_code, &len, path, cmd_ptr);

	output [len - 1] = '\0';

	return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4d90
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x4db0
jmp 0x889d
movq $0x0, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4db0
jmp 0x88b4
leaq -0x38(%rbp), %rdi
callq 0x8fb0
movq -0x88(%rbp), %rdi
movq %rax, -0x60(%rbp)
movb $0x0, -0x69(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x60(%rbp), %r8
leaq -0x68(%rbp), %rdx
callq 0x8310
jmp 0x88e3
movq -0x88(%rbp), %rdi
movq -0x68(%rbp), %rsi
decq %rsi
callq 0x3510
movq %rax, -0x90(%rbp)
jmp 0x88ff
movq -0x90(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, -0x69(%rbp)
testb $0x1, -0x69(%rbp)
jne 0x8949
jmp 0x893d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x895f
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3140
jmp 0x895f
movq -0x88(%rbp), %rdi
callq 0x3140
leaq -0x38(%rbp), %rdi
callq 0x4f00
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x4f00
movq -0x48(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/info-telecom-strasbourg[P]code-generator/src/utils.cpp
// Function: parse_extension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
string parse_extension (string path, string & extension) {
	size_t path_len = path.length();
	string path_extension; 
	int break_point = 0;
	
	for (int i = path_len - 1; i >= 0; i--) {
		if (path[i] == '.') {
			break_point = i;
			break;
		}

		path_extension.push_back(path[i]);
	}

	reverse_str (path_extension);

	extension = path_extension;

	return path.substr(0, path_len - break_point - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, %rax
movq -0x70(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq %rax, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x3410
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x33c0
movl $0x0, -0x44(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jl 0x8aca
movq -0x70(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x3510
movq %rax, -0x78(%rbp)
jmp 0x8a6a
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x8a98
movl -0x48(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x8aca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3140
jmp 0x8b1b
movq -0x70(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x3510
movq %rax, -0x80(%rbp)
jmp 0x8aab
movq -0x80(%rbp), %rax
movsbl (%rax), %esi
leaq -0x40(%rbp), %rdi
callq 0x31d0
jmp 0x8abd
jmp 0x8abf
movl -0x48(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x8a51
leaq -0x40(%rbp), %rdi
callq 0x8980
jmp 0x8ad5
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3030
jmp 0x8ae4
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x44(%rbp), %rcx
notq %rcx
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x3270
jmp 0x8b05
leaq -0x40(%rbp), %rdi
callq 0x3140
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_01/getint.c
// Function: main
int main(void)
{
  int number = 0;

  getint(&number);
  printf("%d\n", number);

  printbuf();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x11a0
movl -0x8(%rbp), %esi
leaq 0xe7b(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1310
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_01/getint.c
// Function: getint
int getint(int *pn)
{
  int c, sign;

  while (isspace(c = getch()))
    ;

  if (!isdigit(c) && c != EOF && c != '+' && c != '-')
  {
    ungetch(c);
    return 0;
  }

  sign = (c == '-') ? -1 : 1;

  if (c == '+' || c == '-')
  {
    if (!isdigit(c = getch()))
    {
      ungetch(c);
      ungetch(sign == 1 ? '+' : '-');
      return 0;
    }
  }

  for (*pn = 0; isdigit(c); c = getch())
  {
    *pn = 10 * *pn + (c - '0');
  }

  *pn = *pn * sign;

  if (c != EOF)
  {
    ungetch(c);
  }

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1050
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x1400
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x11d9
jmp 0x11ac
callq 0x1050
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x1219
cmpl $-0x1, -0x14(%rbp)
je 0x1219
cmpl $0x2b, -0x14(%rbp)
je 0x1219
cmpl $0x2d, -0x14(%rbp)
je 0x1219
movl -0x14(%rbp), %edi
callq 0x1450
movl $0x0, -0x4(%rbp)
jmp 0x12f8
movl -0x14(%rbp), %edx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x2d, %edx
cmovel %ecx, %eax
movl %eax, -0x18(%rbp)
cmpl $0x2b, -0x14(%rbp)
je 0x123b
cmpl $0x2d, -0x14(%rbp)
jne 0x1291
callq 0x1050
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1400
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x128f
movl -0x14(%rbp), %edi
callq 0x1450
movl -0x18(%rbp), %ecx
movl $0x2d, %edi
movl $0x2b, %eax
cmpl $0x1, %ecx
cmovel %eax, %edi
callq 0x1450
movl $0x0, -0x4(%rbp)
jmp 0x12f8
jmp 0x1291
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
callq 0x1050
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x12d4
movq -0x10(%rbp), %rax
imull $0xa, (%rax), %ecx
movl -0x14(%rbp), %eax
subl $0x30, %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
callq 0x1400
movl %eax, -0x14(%rbp)
jmp 0x129b
movq -0x10(%rbp), %rax
movl (%rax), %ecx
imull -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpl $-0x1, -0x14(%rbp)
je 0x12f2
movl -0x14(%rbp), %edi
callq 0x1450
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_01/getint.c
// Function: printbuf
void printbuf(void)
{
  if (bufp)
  {
    printf("Buffer: [ ");

    int i;
    for (i = bufp - 1; i >= 0; --i)
    {
      if (i)
      {
        printf("'%c', ", buf[i] != '\n' ? buf[i] : '.');
      }
      else
      {
        printf("'%c' ", buf[i] != '\n' ? buf[i] : '.');
      }
    }

    printf("]\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x2d31(%rip)      # 0x4050
je 0x13ed
leaq 0xcdc(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1030
movl 0x2d17(%rip), %eax      # 0x4050
subl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x13df
cmpl $0x0, -0x4(%rbp)
je 0x1390
movslq -0x4(%rbp), %rcx
leaq 0x2d06(%rip), %rax      # 0x4060
cmpl $0xa, (%rax,%rcx,4)
je 0x1373
movslq -0x4(%rbp), %rcx
leaq 0x2cf5(%rip), %rax      # 0x4060
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0x137d
movl $0x2e, %eax
movl %eax, -0x8(%rbp)
jmp 0x137d
movl -0x8(%rbp), %esi
leaq 0xc8c(%rip), %rdi       # 0x2013
movb $0x0, %al
callq 0x1030
jmp 0x13cf
movslq -0x4(%rbp), %rcx
leaq 0x2cc5(%rip), %rax      # 0x4060
cmpl $0xa, (%rax,%rcx,4)
je 0x13b4
movslq -0x4(%rbp), %rcx
leaq 0x2cb4(%rip), %rax      # 0x4060
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0x13be
movl $0x2e, %eax
movl %eax, -0xc(%rbp)
jmp 0x13be
movl -0xc(%rbp), %esi
leaq 0xc52(%rip), %rdi       # 0x201a
movb $0x0, %al
callq 0x1030
jmp 0x13d1
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x133f
leaq 0xc3a(%rip), %rdi       # 0x2020
movb $0x0, %al
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wc2o.c
// Function: main
int main(void)
{
    static const unsigned char table[4][3] = {
        {2,0,1}, {2,0,1}, {3,0,1}, {3,0,1}
    };
    static const unsigned char column[256] = {
        0,0,0,0,0,0,0,0,0,1,2,1,1,1,0,0,0, /* \t\n\v\f\r */
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0, /* SPACE ' ' */
    };
    unsigned long counts[4] = {0,0,0,0};
    int state = 0;
    int c;

    while ((c = getchar()) != EOF) {
        state = table[state][column[c]];
        counts[state]++;
    }

    printf("%lu %lu %lu\n", counts[1], counts[2], 
                counts[0] + counts[1] + counts[2] + counts[3]);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1040
movl $0x0, -0x34(%rbp)
callq 0x1050
movl %eax, -0x38(%rbp)
cmpl $-0x1, %eax
je 0x11cf
movslq -0x34(%rbp), %rcx
leaq 0xe72(%rip), %rax       # 0x2010
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movslq -0x38(%rbp), %rdx
leaq 0xe70(%rip), %rcx       # 0x2020
movzbl (%rcx,%rdx), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp,%rax,8)
jmp 0x1186
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
addq -0x28(%rbp), %rcx
addq -0x20(%rbp), %rcx
addq -0x18(%rbp), %rcx
leaq 0xf32(%rip), %rdi       # 0x2120
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_08/_exit.c
// Function: main
int main(int argc, char *argv[])
{
	int ret;

	ret = atexit(func);
	if (ret) {
		fprintf(stderr, "cannot set atexit func\n");
		return -1;
	}

	if (argc >= 2)
		val = atoi(argv[1]);

	printf("this is a message");

	subfunc();

	printf("this point is unreachable!\n");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x4d(%rip), %rdi       # 0x1180
callq 0x1250
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x11fc
movq 0x2e16(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe18(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x123d
cmpl $0x2, -0x8(%rbp)
jl 0x1215
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1070
movl %eax, 0x2e3f(%rip)      # 0x4054
leaq 0xe00(%rip), %rdi       # 0x201c
movb $0x0, %al
callq 0x1040
callq 0x11a0
leaq 0xdff(%rip), %rdi       # 0x202e
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datpts.c
// Function: main
int main(int argc, char *argv[])
{
	int id = atoi(argv[1]);
	if (id == 0)
		grid(10, 10);
	if (id == 1)
		grid(13, 13);
	if (id == 2)
		grid(14, 14);
	if (id == 3)
		grid(15, 15);
	if (id == 4)
		grid(17, 17);
	if (id == 5)
		grid(5, 22);
	if (id == 6)
		grid(3, 37);
	if (id == 7)
		grid2(13, 13, 5, 0);
	if (id == 8)
		grid2(12, 12, 7, 7);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1188
movl $0xa, %esi
movl %esi, %edi
callq 0x1240
cmpl $0x1, -0x14(%rbp)
jne 0x119a
movl $0xd, %esi
movl %esi, %edi
callq 0x1240
cmpl $0x2, -0x14(%rbp)
jne 0x11ac
movl $0xe, %esi
movl %esi, %edi
callq 0x1240
cmpl $0x3, -0x14(%rbp)
jne 0x11be
movl $0xf, %esi
movl %esi, %edi
callq 0x1240
cmpl $0x4, -0x14(%rbp)
jne 0x11d0
movl $0x11, %esi
movl %esi, %edi
callq 0x1240
cmpl $0x5, -0x14(%rbp)
jne 0x11e5
movl $0x5, %edi
movl $0x16, %esi
callq 0x1240
cmpl $0x6, -0x14(%rbp)
jne 0x11fa
movl $0x3, %edi
movl $0x25, %esi
callq 0x1240
cmpl $0x7, -0x14(%rbp)
jne 0x1213
movl $0xd, %esi
movl $0x5, %edx
xorl %ecx, %ecx
movl %esi, %edi
callq 0x12c0
cmpl $0x8, -0x14(%rbp)
jne 0x122c
movl $0xc, %esi
movl $0x7, %ecx
movl %esi, %edi
movl %ecx, %edx
callq 0x12c0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datpts.c
// Function: grid
static void grid(int h, int w)
{
	int i, j;
	printf("%d\n", h * w);
	for (i = 0; i < h; i++)
		for (j = 0; j < w; j++)
			printf("%d %d\n", i, j);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %esi
imull -0x8(%rbp), %esi
leaq 0xdab(%rip), %rdi       # 0x2007
movb $0x0, %al
callq 0x1030
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x12ad
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x12a0
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0xd76(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1279
jmp 0x12a2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x126a
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datpts.c
// Function: grid2
static void grid2(int h, int w, int dy, int dx)
{
	int i, j;
	printf("%d\n", h * w * 2);
	for (i = 0; i < h; i++)
		for (j = 0; j < w; j++)
			printf("%d %d\n", i, j);
	for (i = 0; i < h; i++)
		for (j = 0; j < w; j++)
			printf("%d %d\n", dy + i, dx + j);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %esi
imull -0x8(%rbp), %esi
shll %esi
leaq 0xd23(%rip), %rdi       # 0x2007
movb $0x0, %al
callq 0x1030
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1335
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1328
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq 0xcee(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1301
jmp 0x132a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12f2
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1385
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1378
movl -0xc(%rbp), %esi
addl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
addl -0x18(%rbp), %edx
leaq 0xc9e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x134b
jmp 0x137a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x133c
addq $0x20, %rsp
popq %rbp
retq