LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/johnvtan[P]ccccc/string.c
// Function: string_init
int string_init(string_t *string) {
    if (!string)
        return -1;
    string->buf = malloc(sizeof(char) * STRING_DEFAULT_CAPACITY);
    if (!string->buf)
        return -1;
    string->len = 0;
    string->capacity = STRING_DEFAULT_CAPACITY;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7b0c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7b50
movl $0x8, %edi
callq 0x10e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7b33
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7b50
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x8, 0xc(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/johnvtan[P]ccccc/string.c
// Function: string_free
void string_free(string_t *string) {
    if (!string)
        return;
    if (string->buf)
        free(string->buf);
    free(string);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7c45
jmp 0x7c64
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7c5b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johnvtan[P]ccccc/string.c
// Function: string_eq
int string_eq(string_t *s1, string_t *s2) {
    // I guess they might be equal if the user passes in two NULL pointers, but I'm going to say
    // that's invalid
    if (!s1 || !s2)
        return -1;
    
    if (s1->len != s2->len)
        return -1;

    // I'm pretty sure this handles empty string, but I'm not sure
    for (int i = 0; i < s1->len; i++) {
        if (s1->buf[i] != s2->buf[i]) {
            return -1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7c8a
cmpq $0x0, -0x18(%rbp)
jne 0x7c93
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7cfe
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x7cac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7cfe
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x7cf7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x7cea
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7cfe
jmp 0x7cec
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7cb3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/johnvtan[P]ccccc/tokenize.c
// Function: is_whitespace
static bool is_whitespace(char c) {
    switch (c) {
        case ' ':
        case '\n':
        case '\t':
            return true;
        default:
            return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x7ed5
jmp 0x7ecb
movl -0x8(%rbp), %eax
subl $0x20, %eax
jne 0x7edb
jmp 0x7ed5
movb $0x1, -0x1(%rbp)
jmp 0x7edf
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johnvtan[P]ccccc/tokenize.c
// Function: string_literal
static int string_literal(char *p, token_t *token) {
    if (*p != '"')
        return -1;
    (void)token;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x7f11
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7f18
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/johnvtan[P]ccccc/tokenize.c
// Function: number_literal
static int number_literal(char *p, token_t *token) {
    if (!isdigit(*p))
        return -1;
    char *end = p;
    token->type = TOK_INT_LIT;
    token->int_literal = strtol(p, &end, 10);
    return end - p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x1120
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x7f59
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7f94
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0xa, %edx
callq 0x10c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/johnvtan[P]ccccc/tokenize.c
// Function: char_literal
static int char_literal(char *p, token_t *token) {
    if (*p != '\'')
        return -1;
    (void)token;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x7fc1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7fc8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/johnvtan[P]ccccc/tokenize.c
// Function: keyword
static int keyword(char *p, token_t *token) {
    int i = 0;
    while (keywords[i].keyword != NULL) {
        if (startswith(p, keywords[i].keyword)) {
            token->type = keywords[i].type;
            return strlen(keywords[i].keyword);
        }
        i++;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x4c9e(%rip), %rax      # 0xcc90
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x806b
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x4c82(%rip), %rax      # 0xcc90
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x8390
testb $0x1, %al
jne 0x8023
jmp 0x805d
movslq -0x1c(%rbp), %rcx
leaq 0x4c62(%rip), %rax      # 0xcc90
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movslq -0x1c(%rbp), %rcx
leaq 0x4c47(%rip), %rax      # 0xcc90
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x1060
movl %eax, -0x4(%rbp)
jmp 0x8072
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7fe7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johnvtan[P]ccccc/tokenize.c
// Function: special_char
static int special_char(char *p, token_t *token) {
    int i = 0;
    while (special_chars[i].c) {
        if (*p == special_chars[i].c) {
            token->type = special_chars[i].type;
            return 1;
        }
        i++;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x1c82(%rip), %rax      # 0x9d20
cmpb $0x0, (%rax,%rcx,8)
je 0x80e7
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movslq -0x1c(%rbp), %rdx
leaq 0x1c6a(%rip), %rcx      # 0x9d20
movsbl (%rcx,%rdx,8), %ecx
cmpl %ecx, %eax
jne 0x80dc
movslq -0x1c(%rbp), %rcx
leaq 0x1c57(%rip), %rax      # 0x9d20
movl 0x4(%rax,%rcx,8), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x80ee
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8093
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johnvtan[P]ccccc/tokenize.c
// Function: identifier
static int identifier(char *p, token_t *token) {
    // identifiers can only begin with a letter or underscore
    if (!isalpha(*p) && *p != '_')
        return -1;

    // an identifier can consist of numbers, letters, underscores
    token->type = TOK_IDENT;
    token->ident = string_new();
    while (*p) {
        if (!isalpha(*p) && !isdigit(*p) && *p != '_')
            break;
        string_add(token->ident, *p++);
    }
    return token->ident->len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x1120
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x8148
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
je 0x8148
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x81e8
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
callq 0x7a40
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x81da
callq 0x1120
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x81b9
callq 0x1120
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x81b9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
je 0x81b9
jmp 0x81da
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %esi
callq 0x7b60
jmp 0x8162
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/johnvtan[P]ccccc/tokenize.c
// Function: print_token
void print_token(token_t *token) {
    if (!token)
        return;

    if (token->type == TOK_INT_LIT) {
        printf("integer literal: %d\n", token->int_literal);
        return;
    }

    if (token->type == TOK_CHAR_LIT) {
        printf("char literal: %c\n", token->char_literal);
        return;
    }

    if (token->type == TOK_IDENT) {
        printf("identifier: %s\n", string_get(token->ident));
        return;
    }

    // try special chars and keywords now
    keyword_pair_t keyword;
    int i = 0;
    do {
        keyword = keywords[i++];
        if (token->type == keyword.type) {
            printf("keyword: %s\n", keyword.keyword);
            return;
        }
    } while (keyword.keyword);

    special_char_pair_t special;
    i = 0;
    do {
        special = special_chars[i++];
        if (token->type == special.type) {
            printf("special char: %c\n", special.c);
            return;
        }
    } while (special.c);

    printf("UNKNOWN TOKEN!!!!!!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8258
jmp 0x837e
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x827b
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x19d1(%rip), %rdi      # 0x9c40
movb $0x0, %al
callq 0x1070
jmp 0x837e
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x829f
movq -0x8(%rbp), %rax
movsbl 0x8(%rax), %esi
leaq 0x19c2(%rip), %rdi      # 0x9c55
movb $0x0, %al
callq 0x1070
jmp 0x837e
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x82cb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7bf0
movq %rax, %rsi
leaq 0x19a8(%rip), %rdi      # 0x9c67
movb $0x0, %al
callq 0x1070
jmp 0x837e
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %eax, %rcx
leaq 0x49a9(%rip), %rax      # 0xcc90
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x831c
movq -0x18(%rbp), %rsi
leaq 0x1964(%rip), %rdi      # 0x9c77
movb $0x0, %al
callq 0x1070
jmp 0x837e
jmp 0x831e
cmpq $0x0, -0x18(%rbp)
jne 0x82d2
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %eax, %rcx
leaq 0x19df(%rip), %rax      # 0x9d20
movq (%rax,%rcx,8), %rax
movq %rax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0x20(%rbp), %eax
jne 0x8368
movsbl -0x24(%rbp), %esi
leaq 0x1925(%rip), %rdi      # 0x9c84
movb $0x0, %al
callq 0x1070
jmp 0x837e
jmp 0x836a
cmpb $0x0, -0x24(%rbp)
jne 0x832c
leaq 0x191f(%rip), %rdi      # 0x9c96
movb $0x0, %al
callq 0x1070
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_6/exercise_6_05/undef.c
// Function: main
int main(void)
{
  install("TEST", "test");

  // Install other collision values for the same hash as for "TEST" -> 51.
  install("TSHe", "test1");
  install("UPXD", "test2");
  install("9iww", "test3");
  install("mY1a", "test4");
  install("uuoT", "test5");

  struct list_node *node_p = lookup("TEST");
  if (node_p == NULL)
  {
    puts("Error: hash value not found.");
  }
  else
  {
    printf("%s: %s\n", node_p->name, node_p->definition);
    if (undef("TEST") && lookup("TEST") == NULL)
    {
      printf("'%s' was undefined successfully.\n", "TEST");
    }
    else
    {
      printf("Error: failed to undefine '%s'.\n", "TEST");
    }
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe4e(%rip), %rdi       # 0x2004
leaq 0xe4c(%rip), %rsi       # 0x2009
callq 0x12c0
leaq 0xe45(%rip), %rdi       # 0x200e
leaq 0xe43(%rip), %rsi       # 0x2013
callq 0x12c0
leaq 0xe3d(%rip), %rdi       # 0x2019
leaq 0xe3b(%rip), %rsi       # 0x201e
callq 0x12c0
leaq 0xe35(%rip), %rdi       # 0x2024
leaq 0xe33(%rip), %rsi       # 0x2029
callq 0x12c0
leaq 0xe2d(%rip), %rdi       # 0x202f
leaq 0xe2b(%rip), %rsi       # 0x2034
callq 0x12c0
leaq 0xe25(%rip), %rdi       # 0x203a
leaq 0xe23(%rip), %rsi       # 0x203f
callq 0x12c0
leaq 0xddc(%rip), %rdi       # 0x2004
callq 0x13a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1246
leaq 0xe06(%rip), %rdi       # 0x2045
callq 0x1050
jmp 0x12b4
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xe06(%rip), %rdi       # 0x2062
movb $0x0, %al
callq 0x1070
leaq 0xd9a(%rip), %rdi       # 0x2004
callq 0x1410
cmpl $0x0, %eax
je 0x129d
leaq 0xd89(%rip), %rdi       # 0x2004
callq 0x13a0
cmpq $0x0, %rax
jne 0x129d
leaq 0xddd(%rip), %rdi       # 0x206a
leaq 0xd70(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1070
jmp 0x12b2
leaq 0xde8(%rip), %rdi       # 0x208c
leaq 0xd59(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1070
jmp 0x12b4
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_6/exercise_6_05/undef.c
// Function: install
struct list_node *install(char *name, char *definition)
{
  struct list_node *node_p;
  if ((node_p = lookup(name)) == NULL)
  {
    node_p = (struct list_node *)malloc(sizeof(*node_p));
    if (node_p == NULL || (node_p->name = str_dup(name)) == NULL)
    {
      return NULL;
    }
    size_t hash_value = hash(name);
    node_p->next = hash_table[hash_value];
    hash_table[hash_value] = node_p;
  }
  else
  {
    free(node_p->definition);
  }

  if ((node_p->definition = str_dup(definition)) == NULL)
  {
    return NULL;
  }

  return node_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1351
movl $0x18, %edi
callq 0x1090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x130e
movq -0x10(%rbp), %rdi
callq 0x14f0
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x1318
movq $0x0, -0x8(%rbp)
jmp 0x1387
movq -0x10(%rbp), %rdi
callq 0x1540
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
leaq 0x2d40(%rip), %rax      # 0x4070
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x2d25(%rip), %rax      # 0x4070
movq %rdx, (%rax,%rcx,8)
jmp 0x135e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x14f0
movq -0x20(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x137f
movq $0x0, -0x8(%rbp)
jmp 0x1387
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_6/exercise_6_05/undef.c
// Function: lookup
struct list_node *lookup(char *str)
{
  struct list_node *node_p;
  for (node_p = hash_table[hash(str)]; node_p != NULL; node_p = node_p->next)
  {
    if (strcmp(str, node_p->name) == 0)
    {
      return node_p;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1540
movq %rax, %rcx
leaq 0x2cb1(%rip), %rax      # 0x4070
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13fd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x1080
cmpl $0x0, %eax
jne 0x13ed
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1405
jmp 0x13ef
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13c7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_05/undef.c
// Function: undef
enum boolean undef(char *name)
{
  struct list_node *node_p;
  struct list_node *prev_node_p;
  size_t hash_value = hash(name);
  for (node_p = hash_table[hash_value], prev_node_p = NULL;
       node_p != NULL;
       prev_node_p = node_p, node_p = node_p->next)
  {
    if (strcmp(name, node_p->name) == 0)
    {
      free(node_p->name);
      free(node_p->definition);

      if (prev_node_p == NULL)
      {
        hash_table[hash_value] = node_p->next;
      }
      else
      {
        prev_node_p->next = node_p->next;
      }

      free(node_p);
      return TRUE;
    }
  }

  return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1540
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
leaq 0x2c3c(%rip), %rax      # 0x4070
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14da
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x1080
cmpl $0x0, %eax
jne 0x14bf
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
cmpq $0x0, -0x20(%rbp)
jne 0x149d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x28(%rbp), %rcx
leaq 0x2bd9(%rip), %rax      # 0x4070
movq %rdx, (%rax,%rcx,8)
jmp 0x14ad
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x14e1
jmp 0x14c1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1444
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_05/undef.c
// Function: hash
size_t hash(char *str)
{
  size_t hash_value = 0;
  while (*str != '\0')
  {
    hash_value = *str + 31 * hash_value;
    ++str;
  }
  return hash_value % HASH_SIZE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x157e
movq -0x8(%rbp), %rax
movsbq (%rax), %rax
imulq $0x1f, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1550
movq -0x10(%rbp), %rax
movl $0x65, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./f1.c
// Function: foptoa
char *foptoa(struct fctx *cctx, struct v *v) {
    struct v *c, *e, *n;
    for (c = cctx->env; c; c = cdr(c)) {
        n = caar(c); e = cdar(c);
        if ((v == (fwordp(v) ? e : car(e))))
            return str(n);
    }
    return "<undef>";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1be8
movq -0x20(%rbp), %rdi
callq 0x14f0
movq %rax, %rdi
callq 0x14f0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14f0
movq %rax, %rdi
callq 0x1520
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1b9a
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1b9a
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x1b9a
movb $0x1, %al
testb $0x1, %al
jne 0x1ba2
jmp 0x1bac
xorl %eax, %eax
testb $0x1, %al
jne 0x1ba2
jmp 0x1bac
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x1bb9
movq -0x28(%rbp), %rdi
callq 0x14f0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1bd4
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1bf3
jmp 0x1bd6
movq -0x20(%rbp), %rdi
callq 0x1520
movq %rax, -0x20(%rbp)
jmp 0x1b2f
leaq 0xe950(%rip), %rax      # 0x1053f
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./l1.c
// Function: eval
v *
eval(ctx *cctx, v *e, v *env) 
{
    v *r = 0, *f;
    switch(e->tag) {
    case INT: case STR:
        r = e;
        break;
    case SYM:
        if (QUOTED(e)) {
            r = e;
        } else {
            if ((r = assq(e, env))) {
                r = cdr(r);
            } else {
                fprintf(stderr, "Undefined symbol \"%s\"\n", str(e));
            }
        }
        break;
    case FUNC:
        break;
    case CONS:
        if (QUOTED(e)) {
            r = evargs(cctx, e, env);
        } else {
            f = eval(cctx, car(e), env);
            r = apply(cctx, f, cdr(e), env);
        }
        break;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x4, %eax
ja 0x28c2
movq -0x30(%rbp), %rax
leaq 0xd865(%rip), %rcx      # 0x10024
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x28c2
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x27f0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2838
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1aa0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2816
movq -0x20(%rbp), %rdi
callq 0x1520
movq %rax, -0x20(%rbp)
jmp 0x2836
movq 0x117db(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xd933(%rip), %rsi      # 0x10162
movb $0x0, %al
callq 0x1090
jmp 0x2838
jmp 0x28c2
jmp 0x28c2
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x286a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2c90
movq %rax, -0x20(%rbp)
jmp 0x28c0
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14f0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x2780
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1520
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x2dd0
movq %rax, -0x20(%rbp)
jmp 0x28c2
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./l1.c
// Function: evbind
v *
evbind(v *n, v *a, v *ev)
{
    if (ConsP(n)) {
        for (; n; n = cdr(n), a = cdr(a)) {
            ev = mkCons(mkCons(car(n), car(a)),ev);
        }
    } else {
        ev = mkCons(mkCons(n,a),ev);
    }
    return ev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2da2
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x2da2
jmp 0x2d4b
cmpq $0x0, -0x8(%rbp)
je 0x2da0
movq -0x8(%rbp), %rdi
callq 0x14f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14f0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1340
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1340
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1520
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1520
movq %rax, -0x10(%rbp)
jmp 0x2d4b
jmp 0x2dbf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1340
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1340
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./l1.c
// Function: apply
v *
apply(ctx *cctx, v *fn, v *args, v *env) 
{
    v *r = 0, *benv;
    if (!fn)
        return 0;
    switch(fn->tag) {
    case OP:
        if (OP_ARGEVALP(fn))
            args = evargs(cctx,args,env);
        r = op(fn)(cctx, args, env);
        break;
    case FUNC:
        benv = env;
        if (FN_ARGEVALP(fn))
            args = evargs(cctx,args,env);
        if (FN_FUNCENVP(fn))
            benv = funcenv(fn);
        if (FN_ARGBINDP(fn))
            benv = evbind(car(func(fn)), args, benv);
        r = evlist(cctx, cdr(func(fn)),benv);
        break;
    default:
        fprintf(stderr, "Cannot apply to "); print(cctx, stderr, fn); fprintf(stderr, "\n"); 
        break;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2e04
movq $0x0, -0x8(%rbp)
jmp 0x2f61
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
movl %eax, -0x3c(%rbp)
subl $0x4, %eax
je 0x2e6a
jmp 0x2e17
movl -0x3c(%rbp), %eax
subl $0x5, %eax
jne 0x2f12
jmp 0x2e25
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2e4b
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2c90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movq %rax, -0x30(%rbp)
jmp 0x2f59
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2e98
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2c90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2eb5
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2ee7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14f0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x2d20
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1520
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq -0x38(%rbp), %rdx
callq 0x28d0
movq %rax, -0x30(%rbp)
jmp 0x2f59
movq 0x110df(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xd256(%rip), %rsi      # 0x10179
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
movq 0x110c3(%rip), %rax     # 0x13ff8
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x1c80
movq 0x110b0(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xd225(%rip), %rsi      # 0x10177
movb $0x0, %al
callq 0x1090
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./l1.c
// Function: unique
v *
unique(ctx *cctx, char *s, int l) 
{
    v *v; char *cmp;
    for (v = cctx->sym; v; v = cdr(v)) {
        cmp = str(car(v));
        if (strlen(cmp) == l && strncasecmp(cmp, s, l) == 0) {
            return car(v);
        }
    }
    if (!v) {
        cctx->sym = mkCons((v = mkSym(s,l)), cctx->sym);
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2fee
movq -0x28(%rbp), %rdi
callq 0x14f0
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1040
movslq -0x1c(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2fdd
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x10d0
cmpl $0x0, %eax
jne 0x2fdd
movq -0x28(%rbp), %rdi
callq 0x14f0
movq %rax, -0x8(%rbp)
jmp 0x302b
jmp 0x2fdf
movq -0x28(%rbp), %rdi
callq 0x1520
movq %rax, -0x28(%rbp)
jmp 0x2f8e
cmpq $0x0, -0x28(%rbp)
jne 0x3023
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x3, %edx
callq 0x1450
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1340
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./l1.c
// Function: nth
v *
_nth(v *v, int i, int f)
{
    struct v *r;
    if (f && !v) {
        v = mkCons(0,0);
    }
    while(v && (i-- > 0)) {
        if (!(v = cdr(r = v))) {
            if (f)
                rplacd(r, v = mkCons(0,0));
        }
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x306f
cmpq $0x0, -0x8(%rbp)
jne 0x306f
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x1340
movq %rax, -0x8(%rbp)
jmp 0x3071
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x19(%rbp)
je 0x3091
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x309a
jmp 0x30e4
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1520
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x30e2
cmpl $0x0, -0x10(%rbp)
je 0x30e0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x1340
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq %rdx, -0x8(%rbp)
movl $0x1, %esi
callq 0x1600
jmp 0x30e2
jmp 0x3071
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./l1.c
// Function: nreverse
v *
nreverse(v *v)
{
    struct v *r = 0, *h, *l = v, *lt, *c, *p, *n, *t;
    int tq = 0;
    h = l;
    lt = c = cdr(l);
    if (c) {
        if (cdr(c)) {
            p = 0;
            do {
                n = cdr(c);
                rplacd(c,p);
                p = c;
                c = n;
            } while(cdr(c));
            rplacd(l, p);
            rplacd(lt, c);
        }
        /* swap head,c */
        tq = QUOTED(h);
        t = car(h);
        QUOTEV(h, QUOTED(c));
        rplaca(h, car(c));
        rplaca(c, t);
        QUOTEV(c, tq);
    }
    return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1520
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x328d
movq -0x30(%rbp), %rdi
callq 0x1520
cmpq $0x0, %rax
je 0x31b0
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1520
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl $0x1, %esi
callq 0x1600
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1520
cmpq $0x0, %rax
jne 0x314e
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl $0x1, %esi
callq 0x1600
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x1, %esi
callq 0x1600
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x8, %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14f0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x31fd
movq -0x18(%rbp), %rax
movl (%rax), %edx
shrl $0x4, %edx
orl $0x8, %edx
movl (%rax), %ecx
andl $0xfffffff, %edx        # imm = 0xFFFFFFF
shll $0x4, %edx
andl $0xf, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
jmp 0x321b
movq -0x18(%rbp), %rax
movl (%rax), %edx
shrl $0x4, %edx
andl $-0x9, %edx
movl (%rax), %ecx
andl $0xfffffff, %edx        # imm = 0xFFFFFFF
shll $0x4, %edx
andl $0xf, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
callq 0x14f0
movq -0x58(%rbp), %rdi
movq %rax, %rdx
xorl %esi, %esi
callq 0x1600
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rdx
xorl %esi, %esi
callq 0x1600
cmpl $0x0, -0x4c(%rbp)
je 0x326f
movq -0x30(%rbp), %rax
movl (%rax), %edx
shrl $0x4, %edx
orl $0x8, %edx
movl (%rax), %ecx
andl $0xfffffff, %edx        # imm = 0xFFFFFFF
shll $0x4, %edx
andl $0xf, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
jmp 0x328d
movq -0x30(%rbp), %rax
movl (%rax), %edx
shrl $0x4, %edx
andl $-0x9, %edx
movl (%rax), %ecx
andl $0xfffffff, %edx        # imm = 0xFFFFFFF
shll $0x4, %edx
andl $0xf, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./l1.c
// Function: sreverse
v *
sreverse(v *v)
{
    struct v *r = 0, *h, *e, *l = v, *n;
    if (!v)
        return v;
    h = l;
    n = cdr(l);
    rplacd(l,0); 
    while (e = n) {
        n = cdr(n);
        rplacd(e,h); 
        h = e;
    } 
    return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x32cd
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3333
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1520
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1600
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x332b
movq -0x38(%rbp), %rdi
callq 0x1520
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1, %esi
callq 0x1600
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x32f4
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./f1.c
// Function: comma
v *
comma(fctx *cctx, struct v *f, struct v *v) 
{
    struct v *e, *l = cdr(f); 
    rplaca(l,v);
    rplacd(f,e=mkCons(0,cdr(f)));
    FPRINTF(FDBG, "%-10s: @ ",""); 
    dbgfdef(cctx, car(f), cdr(f)); FPRINTF(FDBG, "\n");
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1520
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x1600
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1520
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x1340
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq %rdx, -0x20(%rbp)
movl $0x1, %esi
callq 0x1600
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14f0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1520
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x65e0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./f1.c
// Function: key
int 
key(fctx *cctx)
{
    int c = EOF;
    if (cctx->fc >= 0) {
        while ((c = getc(cctx->f[cctx->fc])) == EOF) {
            fclose(cctx->f[cctx->fc--]);
            if (cctx->fc < 0)
                return c;
        }
    }
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jl 0x7be5
jmp 0x7b83
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x90(%rcx), %rcx
movq 0x10(%rax,%rcx,8), %rdi
callq 0x1140
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x7be3
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x90(%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, 0x90(%rdx)
movq 0x10(%rax,%rcx,8), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jge 0x7be1
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7beb
jmp 0x7b83
jmp 0x7be5
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./f1.c
// Function: dbgstk
void
dbgstk(fctx *cctx, v *c) {
    FPRINTF(FDBG, "["); 
    for (; c && ConsP(c); c = cdr(c)) {
        if (!RECSTK && ConsP(car(c))) {
            FPRINTF(FDBG, "(.0x%p.) ",car(c));    
        } else {
            PRINT(LCTX, FDBG, car(c));  FPRINTF(FDBG, " ");
        }
    }
    FPRINTF(FDBG, "]"); fflush(FDBG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x9270
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x12(%rbp)
je 0x926a
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x9279
jmp 0x92b0
movq -0x10(%rbp), %rdi
callq 0x14f0
cmpq $0x0, %rax
je 0x929d
movq -0x10(%rbp), %rdi
callq 0x14f0
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x929d
jmp 0x929f
jmp 0x929f
jmp 0x92a1
movq -0x10(%rbp), %rdi
callq 0x1520
movq %rax, -0x10(%rbp)
jmp 0x9240
movq 0xad19(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/./f1.c
// Function: find
v *
find(fctx *cctx, v *s)
{
    v *e = 0;
    if ((e = assq(s, cctx->env))) {
        return (e);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rsi
callq 0x1aa0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xf1b0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf1b8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/f.c
// Function: main
int
main(int argc, char **argv) 
{
    fctx cctx; int c, i; FILE *f; char v[32];
    struct v *fx = 0, *r;
    memset(&cctx,0,sizeof(cctx));

    atexit(colreset);
    signal(SIGINT, sigint);
    
    /* input */
    cctx.f[cctx.fc = 0] = stdin;
    for (i = argc-1; i >= 1; i--) {
        if (f = fopen(argv[i],"r")) {
            cctx.f[++cctx.fc] = f;
        }
    }
    
    f_init(&cctx) ;
    
    r = mkCons(g_QUIT, 0);
    cctx.ip = r;
    fx = NEXT(&cctx);
    
    /* main loop */
    while(fx) {
        fx = fop(fx)(&cctx);
    }

    fprintf(FDBG, "[39m"); /* col def */
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x1c8(%rbp)
leaq -0x188(%rbp), %rdi
xorl %esi, %esi
movl $0x178, %edx            # imm = 0x178
callq 0x1070
leaq -0x5e(%rip), %rdi       # 0xf1f0
callq 0xf3a0
movl $0x2, %edi
leaq -0x8f(%rip), %rsi       # 0xf1d0
callq 0x1080
movq 0x4d6d(%rip), %rax      # 0x13fd8
movq (%rax), %rax
movq $0x0, -0xf8(%rbp)
movq %rax, -0x178(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x190(%rbp)
cmpl $0x1, -0x190(%rbp)
jl 0xf2f4
movq -0x10(%rbp), %rax
movslq -0x190(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x1204(%rip), %rsi      # 0x104af
callq 0x1100
movq %rax, -0x198(%rbp)
cmpq $0x0, %rax
je 0xf2e1
movq -0x198(%rbp), %rcx
movq -0xf8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0xf8(%rbp)
movq %rcx, -0x170(%rbp,%rax,8)
jmp 0xf2e3
movl -0x190(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x190(%rbp)
jmp 0xf28c
leaq -0x188(%rbp), %rdi
callq 0x9510
movq 0x52d1(%rip), %rdi      # 0x145d8
xorl %eax, %eax
movl %eax, %esi
callq 0x1340
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x14f0
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rdi
callq 0x1520
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x14f0
movq %rax, -0x1c8(%rbp)
cmpq $0x0, -0x1c8(%rbp)
je 0xf370
movq -0x1c8(%rbp), %rax
leaq -0x188(%rbp), %rdi
callq *0x8(%rax)
movq %rax, -0x1c8(%rbp)
jmp 0xf34c
movq 0x4c59(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
leaq 0x11d2(%rip), %rsi      # 0x10553
movb $0x0, %al
callq 0x1090
xorl %eax, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/6-Memory/constant_array.c
// Function: main
int main(void) {
	char string[]  = "hello";  //you initialized a local array in the stack, which is not read-only
	printf("\"hello\"      = %p\n", "hello");
	printf("String pointer = %p\n", string);
	string[4] = '\0';
	printf("Go to %s\n", string);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl 0xeaf(%rip), %eax       # 0x2004
movl %eax, -0xa(%rbp)
movw 0xea9(%rip), %ax        # 0x2008
movw %ax, -0x6(%rbp)
leaq 0xea0(%rip), %rdi       # 0x200a
leaq 0xe93(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1030
leaq -0xa(%rbp), %rsi
leaq 0xe9a(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1030
movb $0x0, -0x6(%rbp)
leaq -0xa(%rbp), %rsi
leaq 0xe99(%rip), %rdi       # 0x2032
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_int_atomic_set.c
// Function: shmem_int_atomic_set
void shmem_int_atomic_set( int* ptr, int val, int pe)
{
	int* remote_ptr = (int*)shmem_ptr((void*)ptr, pe ); 
	long* x = (long*)shmem_ptr((void*)&__shmem.lock_atomic_int, pe);
	__set_spin_lock(x);
	*remote_ptr = val;
	__clear_spin_lock(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x2010
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %esi
leaq 0x2fd4(%rip), %rdi      # 0x71e0
addq $0x10, %rdi
callq 0x2010
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4570
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x4530
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/sudoku/sudoku.c
// Function: read_from_file
static int read_from_file(char *filename)
{
  FILE *fh;
  char line[32];
  int n, scan;

  fh = fopen(filename, "r");
  if (fh == NULL)
    return 1;

  while (fgets(line, sizeof(line), fh) != NULL) {
    scan = sscanf(line, "%1d%1d%1d%1d%1d%1d%1d%1d%1d",
      &sudoku[n][0], &sudoku[n][1], &sudoku[n][2],
      &sudoku[n][3], &sudoku[n][4], &sudoku[n][5],
      &sudoku[n][6], &sudoku[n][7], &sudoku[n][8]);
    if (scan == 9) {
      n++;
      if (n == 9)
        break;
    }
  }

  fclose(fh);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x19e8(%rip), %rsi      # 0x3052
callq 0x10e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1686
movl $0x1, -0x14(%rbp)
jmp 0x17c1
jmp 0x1688
leaq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x20, %esi
callq 0x10a0
cmpq $0x0, %rax
je 0x17b1
leaq -0x50(%rbp), %rdi
movslq -0x54(%rbp), %rax
leaq 0x3a2d(%rip), %rdx      # 0x50e0
imulq $0x24, %rax, %rax
addq %rax, %rdx
movslq -0x54(%rbp), %rax
leaq 0x3a1b(%rip), %rcx      # 0x50e0
imulq $0x24, %rax, %rax
addq %rax, %rcx
addq $0x4, %rcx
movslq -0x54(%rbp), %rax
leaq 0x3a05(%rip), %r8       # 0x50e0
imulq $0x24, %rax, %rax
addq %rax, %r8
addq $0x8, %r8
movslq -0x54(%rbp), %rax
leaq 0x39ef(%rip), %r9       # 0x50e0
imulq $0x24, %rax, %rax
addq %rax, %r9
addq $0xc, %r9
movslq -0x54(%rbp), %rax
leaq 0x39d9(%rip), %r14      # 0x50e0
imulq $0x24, %rax, %rax
addq %rax, %r14
addq $0x10, %r14
movslq -0x54(%rbp), %rax
leaq 0x39c3(%rip), %rbx      # 0x50e0
imulq $0x24, %rax, %rax
addq %rax, %rbx
addq $0x14, %rbx
movslq -0x54(%rbp), %rax
leaq 0x39ad(%rip), %r11      # 0x50e0
imulq $0x24, %rax, %rax
addq %rax, %r11
addq $0x18, %r11
movslq -0x54(%rbp), %rax
leaq 0x3997(%rip), %r10      # 0x50e0
imulq $0x24, %rax, %rax
addq %rax, %r10
addq $0x1c, %r10
movslq -0x54(%rbp), %rsi
leaq 0x3981(%rip), %rax      # 0x50e0
imulq $0x24, %rsi, %rsi
addq %rsi, %rax
addq $0x20, %rax
leaq 0x18e3(%rip), %rsi      # 0x3054
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x10d0
movl %eax, -0x58(%rbp)
cmpl $0x9, -0x58(%rbp)
jne 0x17ac
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
cmpl $0x9, -0x54(%rbp)
jne 0x17aa
jmp 0x17b1
jmp 0x17ac
jmp 0x1688
movq -0x28(%rbp), %rdi
callq 0x1050
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/sudoku/sudoku.c
// Function: solve_sudoku
static int solve_sudoku(void)
{
  int sudoku_copied = 0;

  enum {
    STATE_TRY_ALGO_1,
    STATE_TRY_ALGO_2,
    STATE_TRY_NEXT_GUESS,
    STATE_TABLE_COPY,
    STATE_TABLE_DONE,
    STATE_TABLE_FAILED,
  } state;

  guess_y = guess_x = guess_number = 0;
  state = STATE_TRY_ALGO_1;

  while (state != STATE_TABLE_DONE) {
    switch (state) {
    case STATE_TRY_ALGO_1:
      if (solve_sudoku_algorithm_1() == 0)
        state = STATE_TABLE_DONE;
      else
        state = STATE_TRY_ALGO_2;
      break;

    case STATE_TRY_ALGO_2:
      if (solve_sudoku_algorithm_2() > 0)
        state = STATE_TRY_ALGO_1;
      else {
        if (sudoku_copied)
          state = STATE_TRY_NEXT_GUESS;
        else
          state = STATE_TABLE_COPY;
      }
      break;

    case STATE_TABLE_COPY:
      memcpy(sudoku_copy, sudoku, sizeof(sudoku));
      sudoku_copied = 1;
      state = STATE_TRY_NEXT_GUESS;
      break;

    case STATE_TRY_NEXT_GUESS:
      if (apply_next_guess())
        state = STATE_TRY_ALGO_1;
      else
        state = STATE_TABLE_FAILED;
      break;
    
    case STATE_TABLE_FAILED:
    default:
      if (sudoku_copied)
        memcpy(sudoku, sudoku_copy, sizeof(sudoku));
      return 1;
      break;
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x8(%rbp)
movl $0x0, 0x371b(%rip)      # 0x5224
movl $0x0, 0x3715(%rip)      # 0x5228
movl $0x0, 0x370f(%rip)      # 0x522c
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
je 0x1c11
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x1be5
movq -0x18(%rbp), %rax
leaq 0x14ba(%rip), %rcx      # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x1c30
cmpl $0x0, %eax
jne 0x1b66
movl $0x4, -0xc(%rbp)
jmp 0x1b6d
movl $0x1, -0xc(%rbp)
jmp 0x1c0c
callq 0x1d30
cmpl $0x0, %eax
jle 0x1b85
movl $0x0, -0xc(%rbp)
jmp 0x1b9d
cmpl $0x0, -0x8(%rbp)
je 0x1b94
movl $0x2, -0xc(%rbp)
jmp 0x1b9b
movl $0x3, -0xc(%rbp)
jmp 0x1b9d
jmp 0x1c0c
leaq 0x368a(%rip), %rdi      # 0x5230
leaq 0x3533(%rip), %rsi      # 0x50e0
movl $0x144, %edx            # imm = 0x144
callq 0x10b0
movl $0x1, -0x8(%rbp)
movl $0x2, -0xc(%rbp)
jmp 0x1c0c
callq 0x1e20
cmpl $0x0, %eax
je 0x1bda
movl $0x0, -0xc(%rbp)
jmp 0x1be1
movl $0x5, -0xc(%rbp)
jmp 0x1c0c
jmp 0x1be5
cmpl $0x0, -0x8(%rbp)
je 0x1c03
leaq 0x34ee(%rip), %rdi      # 0x50e0
leaq 0x3637(%rip), %rsi      # 0x5230
movl $0x144, %edx            # imm = 0x144
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x1c18
jmp 0x1b24
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)