LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_function.c
// Function: sugarLogin
int sugarLogin(struct soap *soap, const char *soap_endpoint, char *login_name, char *login_pwd, struct ns1__loginResponse *_param_1)
{
    char soap_action[128] = {0};

    memset(soap_action, 0, sizeof(soap_action));
    snprintf(soap_action, sizeof(soap_action), "%s/login", soap_endpoint);
    struct ns1__user_USCOREauth *user_auth = NULL;
    struct name_USCOREvalue_USCORElist *name_value_list = NULL;
    user_auth = (struct ns1__user_USCOREauth*)malloc(sizeof(struct ns1__user_USCOREauth));
    
    char *username = (char*)malloc(256);
    char *password = (char*)malloc(512);
    
    snprintf(username, 256, "%s", login_name);
    char *md_res = MD_5(login_pwd);
    snprintf(password, 512, "%s", md_res);
    //printf("%s\n", password);
    if (md_res) {
        free(md_res);
        md_res = NULL;
    }

    user_auth->user_USCOREname = username;
    user_auth->password = password;
    char *application_name = "UCM6XXX";
    
    int ret = soap_call_ns1__login(soap, soap_endpoint, soap_action, user_auth, application_name, name_value_list, _param_1);

    //SAFE_FREE(username);
    //SAFE_FREE(password);
	if (user_auth)
	{
		SAFE_FREE(user_auth->user_USCOREname);
		SAFE_FREE(user_auth->password);
		free(user_auth);
	}
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, 0x28(%rsp)
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, %rcx
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r12
movaps %xmm0, 0x70(%r12)
movaps %xmm0, 0x60(%r12)
movaps %xmm0, 0x50(%r12)
movaps %xmm0, 0x40(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x764f(%rip), %rdx      # 0x4efb1
movl $0x80, %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x3150
pushq $0x10
popq %rdi
callq 0x3290
movq %rax, %r13
movl $0x100, %edi            # imm = 0x100
callq 0x3290
movq %rax, %r15
movl $0x200, %edi            # imm = 0x200
callq 0x3290
movq %rax, %rbp
leaq 0x67cb(%rip), %r14      # 0x4e168
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0x3150
movq %rbx, %rdi
callq 0x46e12
movq %rax, %rbx
movl $0x200, %esi            # imm = 0x200
movq %rbp, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3150
movq %rbx, %rdi
callq 0x3030
movq %r15, (%r13)
movq %rbp, 0x8(%r13)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x75c6(%rip), %r8       # 0x4efba
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %r9d, %r9d
callq 0x307e4
movl %eax, %ebx
movq (%r13), %rdi
testq %rdi, %rdi
je 0x47a21
callq 0x3030
andq $0x0, (%r13)
movq 0x8(%r13), %rdi
callq 0x3030
movq %r13, %rdi
callq 0x3030
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/loversmile[P]sugarcrm/sugar_function.c
// Function: SGCRMLogin
int SGCRMLogin(SGServerInfo *server_info, char *username, char *password, SGLoginReturn *login_return)
{
    int ret = -1;
    struct ns1__loginResponse *_param_1;
    _param_1 = (struct ns1__loginResponse*)soap_malloc(server_info->soap, sizeof(struct ns1__entry_USCOREvalue));
    ret = sugarLogin(server_info->soap, server_info->soap_endpoint, username, password, _param_1);
    if (ret == SOAP_OK) {
        printf("CRMLogin Success!\n");
        if (login_return) {
            login_return->session_id = strdup(_param_1->return_->id);
        }

        int value_size = _param_1->return_->name_USCOREvalue_USCORElist->__size;
        int i = 0;
        for (i = 0; i < value_size; i++){
            if (!strcmp(_param_1->return_->name_USCOREvalue_USCORElist->__ptr[i]->name, "user_id") && login_return) {
                login_return->user_id = strdup(_param_1->return_->name_USCOREvalue_USCORElist->__ptr[i]->value);
            }
        }
    } else {
        soap_print_fault(server_info->soap, stderr);
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq (%rdi), %rdi
pushq $0x18
popq %rsi
callq 0x35f17
movq %rax, %r15
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x478f9
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x49f56
movq (%r14), %rdi
movq 0x260bd(%rip), %rax     # 0x6fff8
movq (%rax), %rsi
callq 0x460f9
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x53cb(%rip), %rdi      # 0x4f328
callq 0x30a0
movq (%r15), %r14
testq %rbx, %rbx
je 0x49f75
movq (%r14), %rdi
callq 0x33a0
movq %rax, (%rbx)
movq 0x10(%r14), %r15
movl 0x8(%r15), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
leaq 0x261e(%rip), %r14      # 0x4c5ac
cmpq %r13, %r12
je 0x49f43
movq (%r15), %rax
movq (%rax,%r13,8), %rbp
movq (%rbp), %rdi
movq %r14, %rsi
callq 0x3210
testq %rbx, %rbx
je 0x49fbc
testl %eax, %eax
jne 0x49fbc
movq 0x8(%rbp), %rdi
callq 0x33a0
movq %rax, 0x8(%rbx)
incq %r13
jmp 0x49f8e
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference/KeccakP-1600-reference.c
// Function: KeccakP1600_AddBytes
void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 200);
    assert(offset+length <= 200);
    for(i=0; i<length; i++)
        ((unsigned char *)state)[offset+i] ^= data[i];
}

// Assembly:
pushq %rax
cmpl $0xc8, %edx
jae 0x58bf
leal (%rcx,%rdx), %eax
cmpl $0xc8, %eax
ja 0x58de
movl %ecx, %eax
movl %edx, %ecx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x58bd
movb (%rsi,%rdx), %r8b
leal (%rcx,%rdx), %r9d
xorb %r8b, (%rdi,%r9)
incq %rdx
jmp 0x58a7
popq %rax
retq
leaq 0x973a(%rip), %rdi      # 0xf000
leaq 0x9740(%rip), %rsi      # 0xf00d
leaq 0x97b3(%rip), %rcx      # 0xf087
movl $0x9a, %edx
callq 0x5190
leaq 0x97f7(%rip), %rdi      # 0xf0dc
leaq 0x9721(%rip), %rsi      # 0xf00d
leaq 0x9794(%rip), %rcx      # 0xf087
movl $0x9b, %edx
callq 0x5190
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference/KeccakP-1600-reference.c
// Function: KeccakP1600_ExtractAndAddBytes
void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 200);
    assert(offset+length <= 200);
    for(i=0; i<length; i++)
        output[i] = input[i] ^ ((unsigned char *)state)[offset+i];
}

// Assembly:
pushq %rax
cmpl $0xc8, %ecx
jae 0x5cd7
leal (%r8,%rcx), %eax
cmpl $0xc8, %eax
ja 0x5cf6
movl %r8d, %eax
movl %ecx, %ecx
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x5cd5
leal (%rcx,%r8), %r9d
movb (%rdi,%r9), %r9b
xorb (%rsi,%r8), %r9b
movb %r9b, (%rdx,%r8)
incq %r8
jmp 0x5cbb
popq %rax
retq
leaq 0x9322(%rip), %rdi      # 0xf000
leaq 0x9328(%rip), %rsi      # 0xf00d
leaq 0x9505(%rip), %rcx      # 0xf1f1
movl $0x16e, %edx            # imm = 0x16E
callq 0x5190
leaq 0x93df(%rip), %rdi      # 0xf0dc
leaq 0x9309(%rip), %rsi      # 0xf00d
leaq 0x94e6(%rip), %rcx      # 0xf1f1
movl $0x16f, %edx            # imm = 0x16F
callq 0x5190
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference/KeccakP-1600-reference.c
// Function: KeccakP1600_DisplayRoundConstants
void KeccakP1600_DisplayRoundConstants(FILE *f)
{
    unsigned int i;

    for(i=0; i<maxNrRounds; i++) {
        fprintf(f, "RC[%02i][0][0] = ", i);
        fprintf(f, "%08X", (unsigned int)(KeccakRoundConstants[i] >> 32));
        fprintf(f, "%08X", (unsigned int)(KeccakRoundConstants[i] & 0xFFFFFFFFULL));
        fprintf(f, "\n");
    }
    fprintf(f, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9576(%rip), %r14      # 0xf2a0
leaq 0x9fc7(%rip), %r15      # 0xfcf8
pushq $0xa
popq %rbp
xorl %r12d, %r12d
cmpq $0x18, %r12
je 0x5d8b
movq %rbx, %rdi
leaq 0x9520(%rip), %rsi      # 0xf267
movl %r12d, %edx
xorl %eax, %eax
callq 0x56d0
movq (%r14), %r13
movq %r13, %rdx
shrq $0x20, %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x56d0
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x56d0
movl %ebp, %edi
movq %rbx, %rsi
callq 0x5360
incq %r12
addq $0x8, %r14
jmp 0x5d37
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5360
// File: /workspace/github_c_makefile_star2_O2/mflatt[P]gc-demo/gc/mark_and_sweep.c
// Function: allocate
struct node *allocate()
{
  struct gc_node *nh;
  
  if (!free_list) {
    collect_garbage();
    if (!free_list)
      get_more_memory();
  }

  nh = free_list;
  free_list = free_list->next_free;

  return &nh->n;
}

// Assembly:
pushq %rbx
movq 0x2d0c(%rip), %rax      # 0x4060
testq %rax, %rax
jne 0x13e1
xorl %eax, %eax
callq 0x1344
movq 0x2cf5(%rip), %rax      # 0x4060
testq %rax, %rax
jne 0x13e1
pushq $0x18
popq %rdi
callq 0x130c
movq %rax, %rbx
movq 0x2cee(%rip), %rax      # 0x4070
movq %rax, (%rbx)
movq %rbx, 0x2ce4(%rip)      # 0x4070
incl 0x30ee(%rip)            # 0x4480
movl $0xc0000, %edi          # imm = 0xC0000
callq 0x130c
movq %rax, 0x8(%rbx)
xorl %eax, %eax
cmpq $0xc0000, %rax          # imm = 0xC0000
je 0x13c9
movq 0x8(%rbx), %rcx
movq 0x2cab(%rip), %rdx      # 0x4060
movq %rdx, (%rcx,%rax)
addq %rax, %rcx
movq %rcx, 0x2c9d(%rip)      # 0x4060
addq $0x18, %rax
jmp 0x13a2
movl $0x8000, %eax           # imm = 0x8000
addl %eax, 0x30b0(%rip)      # 0x4484
addl %eax, 0x30ae(%rip)      # 0x4488
movq 0x2c7f(%rip), %rax      # 0x4060
movq (%rax), %rcx
movq %rcx, 0x2c75(%rip)      # 0x4060
addq $0x8, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mflatt[P]gc-demo/gc/mark_and_sweep.c
// Function: mark_and_sweep_from_roots
void mark_and_sweep_from_roots()
{
  // printf("Collect garbage\n");

  reset_all_marks();

  /* mark (i.e., find all referenced) */
  for (int i = 0; i < num_roots; i++)
    mark(*(root_addrs[i]));

  /* sweep (i.e., add unmarked to the free list) */
  sweep();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2c74(%rip), %rax      # 0x4070
movq (%rax), %rax
testq %rax, %rax
je 0x141d
xorl %ecx, %ecx
cmpq $0xc0000, %rcx          # imm = 0xC0000
je 0x13fc
movq 0x8(%rax), %rdx
andl $0x0, (%rdx,%rcx)
addq $0x18, %rcx
jmp 0x1406
leaq 0x2c5c(%rip), %rbx      # 0x4080
xorl %r14d, %r14d
movslq 0x2c3a(%rip), %rax      # 0x4068
cmpq %rax, %r14
jge 0x1447
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x14ac
incq %r14
addq $0x8, %rbx
jmp 0x1427
andq $0x0, 0x2c11(%rip)      # 0x4060
leaq 0x2c1a(%rip), %rax      # 0x4070
movl 0x302c(%rip), %ecx      # 0x4488
xorl %edx, %edx
movq (%rax), %rax
testq %rax, %rax
je 0x14a4
andl $0x0, 0x10(%rax)
xorl %esi, %esi
cmpq $0xc0000, %rsi          # imm = 0xC0000
je 0x145e
movq 0x8(%rax), %rdi
cmpl $0x0, (%rdi,%rsi)
je 0x1484
incl 0x10(%rax)
jmp 0x149e
movq %rdx, (%rdi,%rsi)
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rdx, 0x2bca(%rip)      # 0x4060
incl %ecx
movl %ecx, 0x2fea(%rip)      # 0x4488
addq $0x18, %rsi
jmp 0x146c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_17/line_80.c
// Function: main
int main(void)
{
  int len;
  char line[MAXLINE];

  while ((len = get_line(line, MAXLINE)) > 0)
  {
    if (len > LIMIT)
    {
      printf("%s", line);
    }
  }

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movq %rsp, %rbx
leaq 0xea4(%rip), %r14       # 0x2004
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x1192
testl %eax, %eax
jle 0x1185
cmpl $0x51, %eax
jb 0x1160
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1030
jmp 0x1160
xorl %eax, %eax
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_17/line_80.c
// Function: get_line
int get_line(char line[], int max_line_len)
{
  int c, i;

  for (i = 0; i < max_line_len - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
  {
    line[i] = c;
  }

  if (c == '\n')
  {
    line[i] = c;
    ++i;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, %esi
pushq $0x1
popq %r14
cmovgel %esi, %r14d
decl %r14d
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x11cb
callq 0x1040
cmpl $-0x1, %eax
je 0x11c8
cmpl $0xa, %eax
je 0x11c8
movb %al, (%rbx,%r15)
incq %r15
jmp 0x11ab
movl %r15d, %r14d
cmpl $0xa, %eax
jne 0x11da
movl %r14d, %eax
movb $0xa, (%rbx,%rax)
incl %r14d
movslq %r14d, %rax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/openshmem-org[P]openshmem-examples/c++/version.cxx
// Function: main
int
main()
{
    struct utsname u;
    uname(&u);

    shmem_init();

    const int me = shmem_my_pe();
    const int npes = shmem_n_pes();

    int maj, min;
    shmem_info_get_version(&maj, &min);

    char verstring[SHMEM_MAX_NAME_LEN];
    shmem_info_get_name(verstring);

    std::cout << u.nodename
              << " \"" << verstring << "\" "
              << "version " << maj << "." << min
              << " on PE " << me << " of " << npes
              << "\n";

    shmem_finalize();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x290, %rsp            # imm = 0x290
leaq 0xa(%rsp), %rdi
callq 0x1030
callq 0x10d0
callq 0x10a0
movl %eax, %ebp
callq 0x1080
movl %eax, %ebx
leaq 0x4(%rsp), %r15
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1040
leaq 0x190(%rsp), %r12
movq %r12, %rdi
callq 0x1050
leaq 0x4b(%rsp), %rsi
movq 0x2d71(%rip), %rdi      # 0x3fd8
callq 0x1090
leaq 0xd91(%rip), %rsi       # 0x2004
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
movq %r12, %rsi
callq 0x1090
leaq 0xd7a(%rip), %rsi       # 0x2007
movq %rax, %rdi
callq 0x1090
leaq 0xd6e(%rip), %rsi       # 0x200a
movq %rax, %rdi
callq 0x1090
movl (%r15), %esi
movq %rax, %rdi
callq 0x10c0
leaq 0xd5d(%rip), %rsi       # 0x2013
movq %rax, %rdi
callq 0x1090
movl (%r14), %esi
movq %rax, %rdi
callq 0x10c0
leaq 0xd45(%rip), %rsi       # 0x2015
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
movl %ebp, %esi
callq 0x10c0
leaq 0xd34(%rip), %rsi       # 0x201d
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
movl %ebx, %esi
callq 0x10c0
leaq 0xd20(%rip), %rsi       # 0x2022
movq %rax, %rdi
callq 0x1090
callq 0x1060
xorl %eax, %eax
addq $0x290, %rsp            # imm = 0x290
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_3/3.7/sigchld.c
// Function: main
int main ()
{
	/* Handle SIGCHLD by calling clean_up_child_process. */
	struct sigaction sigchld_action;
	memset (&sigchld_action, 0, sizeof (sigchld_action));
	sigchld_action.sa_handler = &clean_up_child_process;
	sigaction (SIGCHLD, &sigchld_action, NULL);

	pid_t pidc;

	if((pidc = fork()) == 0) {
    		printf ("Child process: %d\n", (int)getpid());
    		pid_t pidcc;

		if ((pidcc = fork()) == 0) {
			printf("Child's child process: %d\n", (int)getpid());
		} else {
      			kill((int)getpid(),SIGCHLD);
		}
	}else {
   	 	printf ("Parent process: %d\n", (int)getpid());
      		kill((int)getpid(),SIGCHLD);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x98, %rsp
leaq -0x98(%rbp), %rbx
movl $0x90, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1050
leaq -0x4a(%rip), %rax       # 0x119c
movq %rax, -0x8(%rbx)
pushq $0x11
popq %rdi
leaq -0xa0(%rbp), %rsi
xorl %edx, %edx
callq 0x1070
callq 0x1040
movl %eax, %ebx
callq 0x1090
testl %ebx, %ebx
je 0x1222
leaq 0xe20(%rip), %rdi       # 0x2032
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
callq 0x1090
jmp 0x1242
leaq 0xddb(%rip), %rdi       # 0x2004
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
callq 0x1040
movl %eax, %ebx
callq 0x1090
testl %ebx, %ebx
je 0x1258
pushq $0x11
popq %rsi
movl %eax, %edi
callq 0x1080
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
leaq 0xdb8(%rip), %rdi       # 0x2017
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
jmp 0x124c
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_new_size
static struct cx_column *cx_column_new_size(enum cx_column_type type,
                                            enum cx_encoding_type encoding,
                                            size_t size, size_t count)
{
    struct cx_column *column = calloc(1, sizeof(*column));
    if (!column)
        return NULL;
    if (size) {
#ifdef CX_COLUMN_OVER_ALLOC
        size += CX_COLUMN_OVER_ALLOC;
#endif
        column->buffer.mutable = malloc(size);
        if (!column->buffer.mutable)
            goto error;
#ifdef CX_COLUMN_OVER_ALLOC
        memset(column->buffer.mutable, 0, size);
#endif
        column->size = size;
    }
    column->type = type;
    column->encoding = encoding;
    column->count = count;
    return column;
error:
    free(column);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movl %esi, %ebp
movl %edi, %r15d
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x5480
testq %rax, %rax
je 0x5bc7
movq %rax, %rbx
testq %r12, %r12
je 0x5bb2
movq %r12, %rdi
callq 0x55d0
movq %rax, (%rbx)
testq %rax, %rax
je 0x5bbf
movq %r12, 0x18(%rbx)
movl %r15d, 0x20(%rbx)
movl %ebp, 0x24(%rbx)
movq %r14, 0x8(%rbx)
jmp 0x5bc9
movq %rbx, %rdi
callq 0x5090
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_new_mmapped
struct cx_column *cx_column_new_mmapped(enum cx_column_type type,
                                        enum cx_encoding_type encoding,
                                        const void *ptr, size_t size,
                                        size_t count)
{
    struct cx_column *column = cx_column_new_size(type, encoding, 0, count);
    if (!column)
        return NULL;
    column->offset = size;
    column->size = size;
    column->mmapped = true;
    column->buffer.mmapped = ptr;
    return column;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
xorl %edx, %edx
movq %r8, %rcx
callq 0x5b73
testq %rax, %rax
je 0x5bfd
movq %r14, 0x10(%rax)
movq %r14, 0x18(%rax)
movb $0x1, 0x28(%rax)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_new_compressed
struct cx_column *cx_column_new_compressed(enum cx_column_type type,
                                           enum cx_encoding_type encoding,
                                           void **ptr, size_t size,
                                           size_t count)
{
    if (!size)
        return NULL;
    struct cx_column *column = cx_column_new_size(type, encoding, size, count);
    if (!column)
        return NULL;
    column->offset = size;
    *ptr = column->buffer.mutable;
    return column;
}

// Assembly:
testq %rcx, %rcx
je 0x5c30
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rcx, %rdx
movq %r8, %rcx
callq 0x5b73
testq %rax, %rax
je 0x5c33
movq %r14, 0x10(%rax)
movq (%rax), %rcx
movq %rcx, (%rbx)
jmp 0x5c35
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_put_bit
bool cx_column_put_bit(struct cx_column *column, bool value)
{
    if (column->count % 64 == 0) {
        uint64_t bitset = value != 0;
        return cx_column_put(column, CX_COLUMN_BIT, &bitset, sizeof(uint64_t));
    } else if (column->type != CX_COLUMN_BIT || column->mmapped)
        return false;
    if (value) {
        uint64_t *bitset = (uint64_t *)cx_column_offset(
            column, column->offset - sizeof(uint64_t));
        *bitset |= (uint64_t)1 << column->count;
    }
    column->count++;
    return true;
}

// Assembly:
movq 0x8(%rdi), %rcx
testb $0x3f, %cl
je 0x5c88
cmpl $0x0, 0x20(%rdi)
jne 0x5c85
cmpb $0x0, 0x28(%rdi)
je 0x5ca2
xorl %eax, %eax
retq
pushq %rax
movzbl %sil, %eax
movq %rsp, %rdx
movq %rax, (%rdx)
pushq $0x8
popq %rcx
xorl %esi, %esi
callq 0x5cc7
addq $0x8, %rsp
retq
testb %sil, %sil
je 0x5cbd
movq (%rdi), %rax
movq 0x10(%rdi), %rdx
pushq $0x1
popq %rsi
shlq %cl, %rsi
orq %rsi, -0x8(%rdx,%rax)
movq 0x8(%rdi), %rcx
incq %rcx
movq %rcx, 0x8(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_put
static bool cx_column_put(struct cx_column *column, enum cx_column_type type,
                          const void *value, size_t size)
{
    if (column->mmapped || column->type != type || !value)
        return false;
    if (column->offset + size > column->size)
        if (!cx_column_resize(column, size))
            return false;
    void *slot = (void *)cx_column_tail(column);
    memcpy(slot, value, size);
    column->count++;
    column->offset += size;
    return true;
}

// Assembly:
cmpb $0x0, 0x28(%rdi)
je 0x5cd0
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
xorl %eax, %eax
testq %rdx, %rdx
je 0x5d3e
movq %rdi, %rbx
cmpl %esi, 0x20(%rdi)
jne 0x5d3e
movq %rcx, %r14
movq 0x10(%rbx), %rdi
leaq (%rdi,%rcx), %rax
cmpq 0x18(%rbx), %rax
jbe 0x5d0b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x614c
testb %al, %al
je 0x5d3c
movq 0x10(%rbx), %rdi
addq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5520
movdqu 0x8(%rbx), %xmm0
movq %r14, %xmm1
movdqa 0x52d5(%rip), %xmm2     # 0xb000
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
paddq %xmm0, %xmm2
movdqu %xmm2, 0x8(%rbx)
movb $0x1, %al
jmp 0x5d3e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_put_unit
bool cx_column_put_unit(struct cx_column *column)
{
    switch (column->type) {
        case CX_COLUMN_BIT:
            return cx_column_put_bit(column, false);
        case CX_COLUMN_I32:
            return cx_column_put_i32(column, 0);
        case CX_COLUMN_I64:
            return cx_column_put_i64(column, 0);
        case CX_COLUMN_FLT:
            return cx_column_put_flt(column, 0.0);
        case CX_COLUMN_DBL:
            return cx_column_put_dbl(column, 0.0);
        case CX_COLUMN_STR:
            return cx_column_put_str(column, "");
    }
    return false;
}

// Assembly:
movl 0x20(%rdi), %eax
cmpq $0x5, %rax
ja 0x5e0e
leaq 0x523c(%rip), %rcx      # 0xb010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %esi, %esi
jmp 0x54e0
xorps %xmm0, %xmm0
jmp 0x54a0
xorl %esi, %esi
jmp 0x56f0
xorps %xmm0, %xmm0
jmp 0x57c0
xorl %esi, %esi
jmp 0x5560
leaq 0x65e3(%rip), %rsi      # 0xc3ec
jmp 0x5240
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_cursor_new
struct cx_column_cursor *cx_column_cursor_new(const struct cx_column *column)
{
    struct cx_column_cursor *cursor = malloc(sizeof(*cursor));
    if (!cursor)
        return NULL;
    cursor->column = column;
    cursor->start = cx_column_head(column);
    cursor->end = cx_column_tail(column);
    if (!cx_column_madvise(column, MADV_SEQUENTIAL))
        goto error;
    cx_column_cursor_rewind(cursor);
    return cursor;
error:
    free(cursor);
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl $0x420, %edi            # imm = 0x420
callq 0x55d0
testq %rax, %rax
je 0x5e80
movq %rax, %rbx
movq %r15, (%rax)
movq (%r15), %r14
movq %r14, 0x8(%rax)
movq 0x10(%r15), %rax
addq %r14, %rax
movq %rax, 0x10(%rbx)
cmpb $0x1, 0x28(%r15)
jne 0x5e84
movq 0x18(%r15), %r15
testq %r15, %r15
je 0x5e84
callq 0x58e0
movslq %eax, %rcx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %r14, %rdi
subq %rdx, %rdi
addq %rdx, %r15
pushq $0x2
popq %rdx
movq %r15, %rsi
callq 0x57b0
testl %eax, %eax
je 0x5e84
movq %rbx, %rdi
callq 0x5090
xorl %ebx, %ebx
jmp 0x5e88
movq %r14, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_cursor_skip_bit
size_t cx_column_cursor_skip_bit(struct cx_column_cursor *cursor, size_t count)
{
    assert(count % 64 == 0);
    size_t skipped = cx_column_cursor_skip(cursor, CX_COLUMN_BIT,
                                           sizeof(uint64_t), count / 64);
    skipped *= 64;
    if (!cx_column_cursor_valid(cursor)) {
        size_t trailing_bits = cursor->column->count % 64;
        if (trailing_bits)
            skipped -= 64 - trailing_bits;
    }
    return skipped;
}

// Assembly:
pushq %rbx
movq %rsi, %rcx
testb $0x3f, %cl
jne 0x5eef
movq %rdi, %rbx
shrq $0x6, %rcx
pushq $0x8
popq %rdx
xorl %esi, %esi
callq 0x5f0e
shlq $0x6, %rax
movq 0x18(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
jb 0x5eed
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
movl %ecx, %edx
andl $0x3f, %edx
orq $-0x40, %rcx
testq %rdx, %rdx
cmoveq %rdx, %rcx
addq %rcx, %rax
popq %rbx
retq
leaq 0x5132(%rip), %rdi      # 0xb028
leaq 0x513b(%rip), %rsi      # 0xb038
leaq 0x513d(%rip), %rcx      # 0xb041
movl $0x13b, %edx            # imm = 0x13B
callq 0x5380
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_cursor_skip
static size_t cx_column_cursor_skip(struct cx_column_cursor *cursor,
                                    enum cx_column_type type, size_t size,
                                    size_t count)
{
    assert(cursor->column->type == type);
    size_t remaining =
        ((uintptr_t)cursor->end - (uintptr_t)cursor->position) / size;
    if (remaining < count)
        count = remaining;
    cx_column_cursor_advance(cursor, size * count);
    return count;
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
cmpl %esi, 0x20(%rax)
jne 0x5f42
movq %rdx, %r8
movq 0x10(%rdi), %rax
subq 0x18(%rdi), %rax
xorl %edx, %edx
divq %r8
movq %rax, %rbx
cmpq %rcx, %rax
cmovaeq %rcx, %rbx
imulq %rbx, %r8
movq %r8, %rsi
callq 0x5ff4
movq %rbx, %rax
popq %rbx
retq
leaq 0x5246(%rip), %rdi      # 0xb18f
leaq 0x50e8(%rip), %rsi      # 0xb038
leaq 0x5255(%rip), %rcx      # 0xb1ac
movl $0x130, %edx            # imm = 0x130
callq 0x5380
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_cursor_skip_str
size_t cx_column_cursor_skip_str(struct cx_column_cursor *cursor, size_t count)
{
    assert(cursor->column->type == CX_COLUMN_STR);
    size_t skipped = 0;
    // TODO: vectorise this
    for (; skipped < count && cx_column_cursor_valid(cursor); skipped++)
        cx_column_cursor_advance(cursor, cx_strlen(cursor->position) + 1);
    return skipped;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rax
cmpl $0x5, 0x20(%rax)
jne 0x5fd5
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x5fcc
movq 0x18(%r14), %rdi
cmpq 0x10(%r14), %rdi
jae 0x5fc9
callq 0x5280
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0x5ff4
incq %r15
jmp 0x5fa4
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x50a9(%rip), %rdi      # 0xb085
leaq 0x5055(%rip), %rsi      # 0xb038
leaq 0x50c1(%rip), %rcx      # 0xb0ab
movl $0x171, %edx            # imm = 0x171
callq 0x5380
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_cursor_next_batch_str
const struct cx_string *cx_column_cursor_next_batch_str(
    struct cx_column_cursor *cursor, size_t *available)
{
    assert(cursor->column->type == CX_COLUMN_STR);
    size_t i = 0;
    struct cx_string *strings = (struct cx_string *)cursor->buffer;
    for (; i < CX_BATCH_SIZE && cx_column_cursor_valid(cursor); i++) {
        strings[i].ptr = cursor->position;
        strings[i].len = cx_strlen(cursor->position);
        cx_column_cursor_advance(cursor, strings[i].len + 1);
    }
    *available = i;
    return strings;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rax
cmpl $0x5, 0x20(%rax)
jne 0x612d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %r15
leaq 0x28(%rdi), %r13
xorl %r12d, %r12d
cmpq $0x40, %r12
je 0x611d
movq 0x18(%r14), %rdi
cmpq 0x10(%r14), %rdi
jae 0x611d
movq %rdi, -0x8(%r13)
callq 0x5280
movq %rax, (%r13)
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0x5ff4
incq %r12
addq $0x10, %r13
jmp 0x60eb
movq %r12, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4f51(%rip), %rdi      # 0xb085
leaq 0x4efd(%rip), %rsi      # 0xb038
leaq 0x4fad(%rip), %rcx      # 0xb0ef
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x5380
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/column.c
// Function: cx_column_resize
__attribute__((noinline)) static bool cx_column_resize(struct cx_column *column,
                                                       size_t alloc_size)
{
    size_t size = column->size;
    size_t required_size = column->offset + alloc_size;
#ifdef CX_COLUMN_OVER_ALLOC
    required_size += CX_COLUMN_OVER_ALLOC;
#endif
    while (size < required_size) {
        assert(size * 2 > size);
        size *= 2;
    }
    void *buffer = realloc(column->buffer.mutable, size);
    if (!buffer)
        return false;
#ifdef CX_COLUMN_OVER_ALLOC
    memset((void *)((uintptr_t)buffer + column->offset), 0,
           size - column->offset);
#endif
    column->buffer.mutable = buffer;
    column->size = size;
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
addq 0x10(%rdi), %rsi
cmpq %rsi, %r14
jae 0x616a
testq %r14, %r14
jle 0x618f
addq %r14, %r14
jmp 0x615b
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x5710
testq %rax, %rax
je 0x6181
movq %rax, (%rbx)
movq %r14, 0x18(%rbx)
testq %rax, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4fb6(%rip), %rdi      # 0xb14c
leaq 0x4e9b(%rip), %rsi      # 0xb038
leaq 0x4fb8(%rip), %rcx      # 0xb15c
movl $0xa1, %edx
callq 0x5380
nop
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/compress.c
// Function: cx_compress
void *cx_compress(enum cx_compression_type type, int level, const void *src,
                  size_t src_size, size_t *dest_size)
{
    if (type == CX_COMPRESSION_LZ4)
        return cx_compress_lz4(level, src, src_size, dest_size);
    else if (type == CX_COMPRESSION_LZ4HC)
        return cx_compress_lz4hc(level, src, src_size, dest_size);
    else if (type == CX_COMPRESSION_ZSTD)
        return cx_compress_zstd(level, src, src_size, dest_size);
    else
        return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
cmpl $0x3, %edi
je 0x6272
cmpl $0x2, %edi
je 0x6227
cmpl $0x1, %edi
jne 0x62bc
cmpq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
ja 0x62bc
movl %r15d, %edi
callq 0x5190
testl %eax, %eax
je 0x62bc
movl %eax, %r13d
movslq %eax, %rdi
callq 0x55d0
testq %rax, %rax
je 0x62bc
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
movl %r15d, %edx
movl %r13d, %ecx
movl %ebp, %r8d
callq 0x5770
jmp 0x6267
cmpq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
ja 0x62bc
movl %r15d, %edi
callq 0x5190
testl %eax, %eax
je 0x62bc
movl %eax, %r13d
movslq %eax, %rdi
callq 0x55d0
testq %rax, %rax
je 0x62bc
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
movl %r15d, %edx
movl %r13d, %ecx
movl %ebp, %r8d
callq 0x5060
testl %eax, %eax
je 0x62b4
cltq
movq %rax, (%rbx)
jmp 0x62bf
movq %r15, %rdi
callq 0x5800
testl %eax, %eax
je 0x62bc
movslq %eax, %r13
movq %r13, %rdi
callq 0x55d0
testq %rax, %rax
je 0x62bc
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movl %ebp, %r8d
callq 0x5230
movq %rax, %r15
movq %rax, %rdi
callq 0x5170
testl %eax, %eax
je 0x62d1
movq %r14, %rdi
callq 0x5090
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, (%rbx)
jmp 0x62bf
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/compress.c
// Function: cx_decompress
bool cx_decompress(enum cx_compression_type type, const void *src,
                   size_t src_size, void *dest, size_t dest_size)
{
    if (type == CX_COMPRESSION_LZ4 || type == CX_COMPRESSION_LZ4HC)
        return cx_decompress_lz4(src, src_size, dest, dest_size);
    else if (type == CX_COMPRESSION_ZSTD)
        return cx_decompress_zstd(src, src_size, dest, dest_size);
    else
        return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %rax
movq %rsi, %rdx
leal -0x1(%rdi), %esi
cmpl $0x1, %esi
ja 0x6306
movq %rdx, %rdi
movq %rcx, %rsi
movl %eax, %edx
movl %ebx, %ecx
callq 0x56c0
testl %eax, %eax
setne %cl
cltq
cmpq %rbx, %rax
jmp 0x632c
cmpl $0x3, %edi
jne 0x6333
movq %rcx, %rdi
movq %rbx, %rsi
movq %rax, %rcx
callq 0x5200
movq %rax, %r14
movq %rax, %rdi
callq 0x5170
testl %eax, %eax
sete %cl
cmpq %rbx, %r14
sete %al
andb %cl, %al
jmp 0x6335
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_free
void cx_predicate_free(struct cx_predicate *predicate)
{
    if (predicate->operands) {
        for (size_t i = 0; i < predicate->operand_count; i++)
            if (predicate->operands[i])
                cx_predicate_free(predicate->operands[i]);
        free(predicate->operands);
    }
    if (predicate->string)
        free(predicate->string);
    free(predicate);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x7153
xorl %r14d, %r14d
movq 0x28(%rbx), %rdi
cmpq 0x20(%rbx), %r14
jae 0x714e
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x7149
callq 0x5410
incq %r14
jmp 0x7131
callq 0x5090
movq 0x30(%rbx), %rdi
callq 0x5090
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5090
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_null
struct cx_predicate *cx_predicate_new_null(size_t column)
{
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->type = CX_PREDICATE_NULL;
    predicate->column = column;
    return predicate;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x85e8
testq %rax, %rax
je 0x7193
movl $0x1, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_bit_eq
struct cx_predicate *cx_predicate_new_bit_eq(size_t column, bool value)
{
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->column = column;
    predicate->type = CX_PREDICATE_EQ;
    predicate->column_type = CX_COLUMN_BIT;
    predicate->value.bit = value;
    return predicate;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x85e8
testq %rax, %rax
je 0x71b6
movq %r14, 0x8(%rax)
movq $0x2, (%rax)
movb %bl, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_i32
static struct cx_predicate *cx_predicate_new_i32(size_t column, int32_t value,
                                                 enum cx_predicate_type type)
{
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->column = column;
    predicate->type = type;
    predicate->column_type = CX_COLUMN_I32;
    predicate->value.i32 = value;
    return predicate;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
callq 0x85e8
testq %rax, %rax
je 0x71e8
movq %r14, 0x8(%rax)
movl %ebp, (%rax)
movl $0x1, 0x4(%rax)
movl %ebx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_i64
static struct cx_predicate *cx_predicate_new_i64(size_t column, int64_t value,
                                                 enum cx_predicate_type type)
{
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->column = column;
    predicate->type = type;
    predicate->column_type = CX_COLUMN_I64;
    predicate->value.i64 = value;
    return predicate;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x85e8
testq %rax, %rax
je 0x7223
movq %r14, 0x8(%rax)
movl %ebp, (%rax)
movl $0x2, 0x4(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_flt
static struct cx_predicate *cx_predicate_new_flt(size_t column, float value,
                                                 enum cx_predicate_type type)
{
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->column = column;
    predicate->type = type;
    predicate->column_type = CX_COLUMN_FLT;
    predicate->value.flt = value;
    return predicate;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movss %xmm0, 0x4(%rsp)
movq %rdi, %r14
callq 0x85e8
testq %rax, %rax
je 0x7268
movq %r14, 0x8(%rax)
movl %ebx, (%rax)
movl $0x3, 0x4(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_dbl
static struct cx_predicate *cx_predicate_new_dbl(size_t column, double value,
                                                 enum cx_predicate_type type)
{
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->column = column;
    predicate->type = type;
    predicate->column_type = CX_COLUMN_DBL;
    predicate->value.dbl = value;
    return predicate;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movsd %xmm0, (%rsp)
movq %rdi, %r14
callq 0x85e8
testq %rax, %rax
je 0x72ae
movq %r14, 0x8(%rax)
movl %ebx, (%rax)
movl $0x4, 0x4(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_str
static struct cx_predicate *cx_predicate_new_str(size_t column,
                                                 const char *value,
                                                 enum cx_predicate_type type,
                                                 bool case_sensitive)
{
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->column = column;
    predicate->type = type;
    predicate->column_type = CX_COLUMN_STR;
    size_t length = strlen(value);
#if CX_SSE42
    predicate->string = calloc(1, length + 1 + 16);
#else
    predicate->string = malloc(length + 1);
#endif
    if (!predicate->string)
        goto error;
    memcpy(predicate->string, value, length + 1);
    predicate->value.str.ptr = predicate->string;
    predicate->value.str.len = length;
    predicate->case_sensitive = case_sensitive;
    return predicate;
error:
    free(predicate);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %r12
callq 0x85e8
testq %rax, %rax
je 0x733f
movq %rax, %rbx
movq %r12, 0x8(%rax)
movl %r15d, (%rax)
movl $0x5, 0x4(%rax)
movq %r14, %rdi
callq 0x5280
movq %rax, %r15
leaq 0x1(%rax), %r12
movq %r12, %rdi
callq 0x55d0
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x7337
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5520
movq %r13, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movb %bpl, 0x3c(%rbx)
jmp 0x7341
movq %rbx, %rdi
callq 0x5090
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_custom
struct cx_predicate *cx_predicate_new_custom(size_t column,
                                             enum cx_column_type type,
                                             cx_index_match_rows_t match_rows,
                                             cx_index_match_index_t match_index,
                                             int cost, void *data)
{
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->column = column;
    predicate->type = CX_PREDICATE_CUSTOM;
    predicate->column_type = type;
    predicate->custom.match_rows = match_rows;
    predicate->custom.match_index = match_index;
    predicate->custom.data = data;
    predicate->custom.cost = cost;
    return predicate;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
callq 0x85e8
testq %rax, %rax
je 0x73c0
movq %r13, 0x8(%rax)
movl $0x8, (%rax)
movl %ebp, 0x4(%rax)
movq %r12, 0x40(%rax)
movq %r15, 0x48(%rax)
movq %r14, 0x58(%rax)
movl %ebx, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_operator
static struct cx_predicate *cx_predicate_new_operator(
    enum cx_predicate_type type, size_t count, va_list operands)
{
    if (!count)
        return NULL;
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->operand_count = count;
    predicate->type = type;
    predicate->operands = calloc(count, sizeof(struct cx_predicate *));
    if (!predicate->operands)
        goto error;
    for (size_t i = 0; i < count; i++) {
        predicate->operands[i] = va_arg(operands, struct cx_predicate *);
        if (!predicate->operands[i])
            goto error;
    }
    return predicate;
error:
    cx_predicate_free(predicate);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x74dd
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
callq 0x85e8
testq %rax, %rax
je 0x74dd
movq %rax, %rbx
movq %r15, 0x20(%rax)
movl %ebp, (%rax)
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x5480
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x74d5
movl (%r14), %ecx
xorl %edx, %edx
cmpq %rdx, %r15
je 0x74df
cmpl $0x28, %ecx
ja 0x74ba
movl %ecx, %esi
addq 0x10(%r14), %rsi
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x74c6
movq 0x8(%r14), %rsi
leaq 0x8(%rsi), %rdi
movq %rdi, 0x8(%r14)
movq (%rsi), %rsi
movq %rsi, (%rax,%rdx,8)
incq %rdx
testq %rsi, %rsi
jne 0x74a2
movq %rbx, %rdi
callq 0x5410
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_operator_array
static struct cx_predicate *cx_predicate_new_operator_array(
    enum cx_predicate_type type, size_t count, struct cx_predicate **operands)
{
    if (!count)
        return NULL;
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->operand_count = count;
    predicate->type = type;
    predicate->operands = calloc(count, sizeof(struct cx_predicate *));
    if (!predicate->operands)
        goto error;
    for (size_t i = 0; i < count; i++) {
        predicate->operands[i] = operands[i];
        if (!predicate->operands[i])
            goto error;
    }
    return predicate;
error:
    cx_predicate_free(predicate);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x7552
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
callq 0x85e8
testq %rax, %rax
je 0x7552
movq %rax, %rbx
movq %r15, 0x20(%rax)
movl %ebp, (%rax)
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x5480
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x754a
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0x7554
movq (%r14,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
testq %rdx, %rdx
jne 0x7535
movq %rbx, %rdi
callq 0x5410
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_valid
bool cx_predicate_valid(const struct cx_predicate *predicate,
                        const struct cx_row_group *row_group)
{
    if (predicate->column >= cx_row_group_column_count(row_group))
        return false;

    enum cx_column_type column_type =
        cx_row_group_column_type(row_group, predicate->column);
    if (!cx_predicate_is_operator(predicate) &&
        predicate->type != CX_PREDICATE_TRUE &&
        predicate->type != CX_PREDICATE_NULL &&
        predicate->column_type != column_type)
        return false;

    switch (predicate->type) {
        case CX_PREDICATE_TRUE:
        case CX_PREDICATE_NULL:
        case CX_PREDICATE_EQ:
        case CX_PREDICATE_CUSTOM:
            break;
        case CX_PREDICATE_LT:
        case CX_PREDICATE_GT:
            return column_type != CX_COLUMN_BIT;
        case CX_PREDICATE_CONTAINS:
            return column_type == CX_COLUMN_STR;
        case CX_PREDICATE_AND:
        case CX_PREDICATE_OR:
            for (size_t i = 0; i < predicate->operand_count; i++)
                if (!cx_predicate_valid(predicate->operands[i], row_group))
                    return false;
            break;
    }

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rbx
movq %rsi, %rdi
callq 0x5470
cmpq %rax, %rbx
jae 0x768a
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x5920
movl (%r14), %ecx
movb $0x1, %bl
cmpl $0x2, %ecx
jb 0x768c
leal -0x6(%rcx), %edx
cmpl $0x2, %edx
jae 0x7675
xorl %r12d, %r12d
cmpq 0x20(%r14), %r12
setae %bl
jae 0x768c
movq 0x28(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
callq 0x5110
incq %r12
testb %al, %al
jne 0x7653
jmp 0x768c
cmpl %eax, 0x4(%r14)
jne 0x768a
leal -0x3(%rcx), %edx
cmpl $0x2, %edx
jae 0x769a
testl %eax, %eax
setne %bl
jmp 0x768c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x5, %ecx
jne 0x768c
cmpl $0x5, %eax
sete %bl
jmp 0x768c
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_mask_cap
static inline uint64_t cx_mask_cap(uint64_t mask, size_t count)
{
    assert(count <= 64);
    if (count < 64)
        mask &= ((uint64_t)1 << count) - 1;
    return mask;
}

// Assembly:
cmpq $0x41, %rsi
jae 0x8085
pushq $-0x1
popq %rdx
movq %rdx, %rax
movl %esi, %ecx
shlq %cl, %rax
cmpq $0x40, %rsi
notq %rax
cmoveq %rdx, %rax
andq %rdi, %rax
retq
pushq %rax
leaq 0x3abb(%rip), %rdi      # 0xbb48
leaq 0x3a20(%rip), %rsi      # 0xbab4
leaq 0x3ab9(%rip), %rcx      # 0xbb54
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x5380
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_optimize
void cx_predicate_optimize(struct cx_predicate *predicate,
                           const struct cx_row_group *row_group)
{
#ifdef __APPLE__
    qsort_r(predicate->operands, predicate->operand_count,
            sizeof(struct cx_predicate *), (void *)row_group, cx_predicate_cmp);
#else
    qsort_r(predicate->operands, predicate->operand_count,
            sizeof(struct cx_predicate *), cx_predicate_cmp, (void *)row_group);
#endif
    if (cx_predicate_is_operator(predicate)) {
        for (size_t i = 0; i < predicate->operand_count; i++)
            cx_predicate_optimize(predicate->operands[i], row_group);
        return;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdi
leaq 0x3a(%rip), %rcx        # 0x85b1
pushq $0x8
popq %rdx
movq %rbx, %r8
callq 0x5580
movl (%r14), %eax
andl $-0x2, %eax
cmpl $0x6, %eax
jne 0x85ab
xorl %r15d, %r15d
cmpq 0x20(%r14), %r15
jae 0x85ab
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x5a50
incq %r15
jmp 0x8590
popq %rbx
popq %r14
popq %r15
retq