LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp5.c
// Function: m_rule
void
m_rule(int R_major, int R_minor, char *tag)
{	Rule *r;
	Offd *o;

	if (misra_rules < 2 && stack_depth > 1) return;

	if (strcmp(filename, "<predef>") == 0) return;
	
	for (r = violations; r; r = r->nxt)
		if (r->R_major == R_major
		&&  r->R_minor == R_minor)
		{	for (o = r->lst; o; o = o->nxt)
				if (o->ln == lineno
				&&  strcmp(o->fnm, filename) == 0)
					return;
			break;
		}

	if (!r)
	{	r = (Rule *) emalloc(sizeof(Rule));
		r->R_major = R_major;
		r->R_minor = R_minor;
		r->tag = tag;
		r->nxt = violations;
		violations = r;
	}

	o = (Offd *) emalloc(sizeof(Offd));
	o->fnm = emalloc(strlen(filename)+1);
	strcpy(o->fnm, filename);
	o->ln = lineno;

	o->nxt = r->lst;
	r->lst = o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq 0x852b(%rip), %rax      # 0x14f94
cmpl $0x2, (%rax)
jge 0xca7f
leaq 0xbb17(%rip), %rax      # 0x1858c
cmpl $0x1, (%rax)
jle 0xca7f
jmp 0xcbf9
leaq 0x766a(%rip), %rax      # 0x140f0
movq (%rax), %rdi
leaq 0x988(%rip), %rsi       # 0xd418
callq 0x4100
cmpl $0x0, %eax
jne 0xca9f
jmp 0xcbf9
movq 0xc722(%rip), %rax      # 0x191c8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcb37
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xcb24
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xcb24
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcb22
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
leaq 0x84a2(%rip), %rcx      # 0x14f90
cmpl (%rcx), %eax
jne 0xcb12
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x75f0(%rip), %rax      # 0x140f0
movq (%rax), %rsi
callq 0x4100
cmpl $0x0, %eax
jne 0xcb12
jmp 0xcbf9
jmp 0xcb14
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xcad9
jmp 0xcb37
jmp 0xcb26
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xcaaa
cmpq $0x0, -0x18(%rbp)
jne 0xcb85
movl $0x20, %edi
callq 0x4320
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq 0xc656(%rip), %rcx      # 0x191c8
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0xc643(%rip)      # 0x191c8
movl $0x18, %edi
callq 0x4320
movq %rax, -0x20(%rbp)
leaq 0x7556(%rip), %rax      # 0x140f0
movq (%rax), %rdi
callq 0x4080
addq $0x1, %rax
movl %eax, %edi
callq 0x4320
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x752b(%rip), %rax      # 0x140f0
movq (%rax), %rsi
callq 0x4060
leaq 0x83bc(%rip), %rax      # 0x14f90
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp5.c
// Function: show_violations
void
show_violations(void)
{	Rule *r;

	if (!violations) return;
	
	for (r = violations; r; r = r->nxt)
	{	fprintf(stderr, "non-compliance with misra-rule %d.%d: use of '%s'",
			r->R_major, r->R_minor, r->tag);
		lastnm = (char *) 0;
		show_one(r->lst);
		fprintf(stderr, "\n\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0xc5b8(%rip)      # 0x191c8
jne 0xcc14
jmp 0xcc91
movq 0xc5ad(%rip), %rax      # 0x191c8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcc91
movq 0x73cb(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %r8
leaq 0x4dc1(%rip), %rsi      # 0x11a0d
movb $0x0, %al
callq 0x4110
movq $0x0, 0xc572(%rip) # 0x191d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xcca0
movq 0x7386(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x4399(%rip), %rsi      # 0x11015
movb $0x0, %al
callq 0x4110
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xcc1f
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp5.c
// Function: show_one
static void
show_one(Offd *o)
{
	if (!o) return;
	show_one(o->nxt);

	if (!lastnm || strcmp(lastnm, o->fnm) != 0)
		fprintf(stderr, "\n\t%s:\t", o->fnm);
	fprintf(stderr, "%d, ", o->ln);

	lastnm = o->fnm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xccb5
jmp 0xcd30
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xcca0
cmpq $0x0, 0xc506(%rip)      # 0x191d0
je 0xcce4
movq 0xc4fd(%rip), %rdi      # 0x191d0
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x4100
cmpl $0x0, %eax
je 0xcd03
movq 0x730d(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x4d43(%rip), %rsi      # 0x11a3f
movb $0x0, %al
callq 0x4110
movq 0x72ee(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x4d2b(%rip), %rsi      # 0x11a46
movb $0x0, %al
callq 0x4110
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xc4a0(%rip)      # 0x191d0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/test.c
// Function: connect
static redisContext *connect(struct config config) {
    redisContext *c = NULL;

    if (config.type == CONN_TCP) {
        c = redisConnect(config.tcp.host, config.tcp.port);
    } else if (config.type == CONN_UNIX) {
        c = redisConnectUnix(config.unix.path);
    } else if (config.type == CONN_FD) {
        /* Create a dummy connection just to get an fd to inherit */
        redisContext *dummy_ctx = redisConnectUnix(config.unix.path);
        if (dummy_ctx) {
            int fd = disconnect(dummy_ctx, 1);
            printf("Connecting to inherited fd %d\n", fd);
            c = redisConnectFd(fd);
        }
    } else {
        assert(NULL);
    }

    if (c == NULL) {
        printf("Connection error: can't allocate redis context\n");
        exit(1);
    } else if (c->err) {
        printf("Connection error: %s\n", c->errstr);
        redisFree(c);
        exit(1);
    }

    return select_database(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x8(%rbp)
cmpl $0x0, (%rax)
jne 0x5636
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x6fb0
movq %rax, -0x8(%rbp)
jmp 0x56d2
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x5652
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x72c0
movq %rax, -0x8(%rbp)
jmp 0x56d0
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x56a3
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x72c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x56a1
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5740
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
leaq 0x869e(%rip), %rdi      # 0xdd2c
movb $0x0, %al
callq 0x2100
movl -0x14(%rbp), %edi
callq 0x73f0
movq %rax, -0x8(%rbp)
jmp 0x56ce
xorl %eax, %eax
testb $0x1, %al
jne 0x56ab
jmp 0x56ad
jmp 0x56cc
leaq 0x9282(%rip), %rdi      # 0xe936
leaq 0x820c(%rip), %rsi      # 0xd8c7
movl $0x6e, %edx
leaq 0x8684(%rip), %rcx      # 0xdd4b
callq 0x2140
jmp 0x56ce
jmp 0x56d0
jmp 0x56d2
cmpq $0x0, -0x8(%rbp)
jne 0x56f1
leaq 0x8690(%rip), %rdi      # 0xdd70
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x2290
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x5723
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
leaq 0x8697(%rip), %rdi      # 0xdda0
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rdi
callq 0x6d30
movl $0x1, %edi
callq 0x2290
jmp 0x5725
movq -0x8(%rbp), %rdi
callq 0x5810
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl-keypair.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc != 3) error(2, "Usage: tweetnacl-keypair key.pub key.sec");

    unsigned char public_key[crypto_box_PUBLICKEYBYTES];
    unsigned char secret_key[crypto_box_SECRETKEYBYTES];
    crypto_box_keypair(public_key, secret_key);

    if (file_exists(argv[1])) errorf(1, "File <%s> exists", argv[1]);
    if (file_exists(argv[2])) errorf(1, "File <%s> exists", argv[2]);

    output_key(argv[1], public_key, crypto_box_PUBLICKEYBYTES);
    output_key(argv[2], secret_key, crypto_box_SECRETKEYBYTES);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x512d
movl $0x2, %edi
leaq 0x17ea(%rip), %rsi      # 0x6912
callq 0x1300
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x32a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14c0
cmpl $0x0, %eax
je 0x5165
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x1, %edi
leaq 0x17db(%rip), %rsi      # 0x693b
callq 0x1360
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x14c0
cmpl $0x0, %eax
je 0x5190
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x1, %edi
leaq 0x17b0(%rip), %rsi      # 0x693b
callq 0x1360
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x30(%rbp), %rsi
movl $0x20, %edx
callq 0x5060
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x50(%rbp), %rsi
movl $0x20, %edx
callq 0x5060
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/vocab_count.c
// Function: hashinsert
void hashinsert(HASHREC **ht, char *w) {
    HASHREC     *htmp, *hprv;
    unsigned int hval = HASHFN(w, TSIZE, SEED);
    
    for (hprv = NULL, htmp = ht[hval]; htmp != NULL && scmp(htmp->word, w) != 0; hprv = htmp, htmp = htmp->next);
    if (htmp == NULL) {
        htmp = (HASHREC *) malloc( sizeof(HASHREC) );
        htmp->word = (char *) malloc( strlen(w) + 1 );
        strcpy(htmp->word, w);
        htmp->num = 1;
        htmp->next = NULL;
        if ( hprv==NULL )
            ht[hval] = htmp;
        else
            hprv->next = htmp;
    }
    else {
        /* new records are not moved to front */
        htmp->num++;
        if (hprv != NULL) {
            /* move to front on access */
            hprv->next = htmp->next;
            htmp->next = ht[hval];
            ht[hval] = htmp;
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x100000, %esi         # imm = 0x100000
movl $0x11b049, %edx         # imm = 0x11B049
callq 0x1af0
movl %eax, -0x24(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x25(%rbp)
je 0x1372
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1a80
cmpl $0x0, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x137b
jmp 0x1393
jmp 0x137d
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x134d
cmpq $0x0, -0x18(%rbp)
jne 0x1415
movl $0x18, %edi
callq 0x1100
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1090
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1100
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1050
movq -0x18(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x1407
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x1413
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1460
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x145e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x1460
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Leeheng86[P]word2vec/word2phrase.c
// Function: ReadWord(char*, _IO_FILE*)
void ReadWord(char *word, FILE *fin) {
  int a = 0, ch;
  while (!feof(fin)) {
    ch = fgetc(fin);
    if (ch == 13) continue;
    if ((ch == ' ') || (ch == '\t') || (ch == '\n')) {
      if (a > 0) {
        if (ch == '\n') ungetc(ch, fin);
        break;
      }
      if (ch == '\n') {
        strcpy(word, (char *)"
");
        return;
      } else continue;
    }
    word[a] = ch;
    a++;
    if (a >= MAX_STRING - 1) a--;   // Truncate too long words
  }
  word[a] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1110
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1291
jmp 0x1318
movq -0x10(%rbp), %rdi
callq 0x1130
movl %eax, -0x18(%rbp)
cmpl $0xd, -0x18(%rbp)
jne 0x12a5
jmp 0x1277
cmpl $0x20, -0x18(%rbp)
je 0x12b7
cmpl $0x9, -0x18(%rbp)
je 0x12b7
cmpl $0xa, -0x18(%rbp)
jne 0x12eb
cmpl $0x0, -0x14(%rbp)
jle 0x12d1
cmpl $0xa, -0x18(%rbp)
jne 0x12cf
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1040
jmp 0x1318
cmpl $0xa, -0x18(%rbp)
jne 0x12e9
movq -0x8(%rbp), %rdi
leaq 0x1d2e(%rip), %rsi      # 0x3010
callq 0x1080
jmp 0x1324
jmp 0x1277
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x3b, -0x14(%rbp)
jl 0x1313
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1277
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Leeheng86[P]word2vec/word2phrase.c
// Function: GetWordHash(char*)
int GetWordHash(char *word) {
  unsigned long long a, hash = 1;
  for (a = 0; a < strlen(word); a++) hash = hash * 257 + word[a];
  hash = hash % vocab_hash_size;
  return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x1393
imulq $0x101, -0x18(%rbp), %rax # imm = 0x101
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movsbq (%rcx,%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x134c
movq -0x18(%rbp), %rax
movl $0x1dcd6500, %ecx       # imm = 0x1DCD6500
xorl %edx, %edx
divq %rcx
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Leeheng86[P]word2vec/word2phrase.c
// Function: SearchVocab(char*)
int SearchVocab(char *word) {
  unsigned int hash = GetWordHash(word);
  while (1) {
    if (vocab_hash[hash] == -1) return -1;
    if (!strcmp(word, vocab[vocab_hash[hash]].word)) return vocab_hash[hash];
    hash = (hash + 1) % vocab_hash_size;
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1330
movl %eax, -0x14(%rbp)
movq 0x3db9(%rip), %rax      # 0x5188
movl -0x14(%rbp), %ecx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x13e1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1435
movq -0x10(%rbp), %rdi
movq 0x3d94(%rip), %rax      # 0x5180
movq 0x3d95(%rip), %rcx      # 0x5188
movl -0x14(%rbp), %edx
movslq (%rcx,%rdx,4), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x10f0
cmpl $0x0, %eax
jne 0x1421
movq 0x3d72(%rip), %rax      # 0x5188
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x1435
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0x1dcd6500, %ecx       # imm = 0x1DCD6500
xorl %edx, %edx
divl %ecx
movl %edx, -0x14(%rbp)
jmp 0x13c8
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Leeheng86[P]word2vec/word2phrase.c
// Function: ReadWordIndex(_IO_FILE*)
int ReadWordIndex(FILE *fin) {
  char word[MAX_STRING];
  ReadWord(word, fin);
  if (feof(fin)) return -1;
  return SearchVocab(word);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1260
movq -0x10(%rbp), %rdi
callq 0x1110
cmpl $0x0, %eax
je 0x1470
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x147c
leaq -0x50(%rbp), %rdi
callq 0x13b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Leeheng86[P]word2vec/word2phrase.c
// Function: AddWordToVocab(char*)
int AddWordToVocab(char *word) {
  unsigned int hash, length = strlen(word) + 1;
  if (length > MAX_STRING) length = MAX_STRING;
  vocab[vocab_size].word = (char *)calloc(length, sizeof(char));
  strcpy(vocab[vocab_size].word, word);
  vocab[vocab_size].cn = 0;
  vocab_size++;
  // Reallocate memory if needed
  if (vocab_size + 2 >= vocab_max_size) {
    vocab_max_size += 10000;
    vocab=(struct vocab_word *)realloc(vocab, vocab_max_size * sizeof(struct vocab_word));
  }
  hash = GetWordHash(word);
  while (vocab_hash[hash] != -1) hash = (hash + 1) % vocab_hash_size;
  vocab_hash[hash]=vocab_size - 1;
  return vocab_size - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
addq $0x1, %rax
movl %eax, -0x10(%rbp)
cmpl $0x3c, -0x10(%rbp)
jbe 0x14b9
movl $0x3c, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x1070
movq %rax, %rcx
movq 0x3cae(%rip), %rax      # 0x5180
movq 0x3cb7(%rip), %rdx      # 0x5190
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x3c95(%rip), %rax      # 0x5180
movq 0x3c9e(%rip), %rcx      # 0x5190
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x1080
movq 0x3c73(%rip), %rax      # 0x5180
movq 0x3c7c(%rip), %rcx      # 0x5190
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq 0x3c67(%rip), %rax      # 0x5190
addq $0x1, %rax
movq %rax, 0x3c5c(%rip)      # 0x5190
movq 0x3c55(%rip), %rax      # 0x5190
addq $0x2, %rax
cmpq 0x3b8a(%rip), %rax      # 0x50d0
jl 0x157a
movq 0x3b81(%rip), %rax      # 0x50d0
addq $0x2710, %rax           # imm = 0x2710
movq %rax, 0x3b74(%rip)      # 0x50d0
movq 0x3c1d(%rip), %rdi      # 0x5180
movq 0x3b66(%rip), %rsi      # 0x50d0
shlq $0x4, %rsi
callq 0x1140
movq %rax, 0x3c06(%rip)      # 0x5180
movq -0x8(%rbp), %rdi
callq 0x1330
movl %eax, -0xc(%rbp)
movq 0x3bfb(%rip), %rax      # 0x5188
movl -0xc(%rbp), %ecx
cmpl $-0x1, (%rax,%rcx,4)
je 0x15aa
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl $0x1dcd6500, %ecx       # imm = 0x1DCD6500
xorl %edx, %edx
divl %ecx
movl %edx, -0xc(%rbp)
jmp 0x1586
movq 0x3bdf(%rip), %rax      # 0x5190
subq $0x1, %rax
movl %eax, %edx
movq 0x3bca(%rip), %rax      # 0x5188
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq 0x3bc5(%rip), %rax      # 0x5190
subq $0x1, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Leeheng86[P]word2vec/word2phrase.c
// Function: SortVocab()
void SortVocab() {
  int a;
  unsigned int hash;
  // Sort the vocabulary and keep 
 at the first position
  qsort(&vocab[1], vocab_size - 1, sizeof(struct vocab_word), VocabCompare);
  for (a = 0; a < vocab_hash_size; a++) vocab_hash[a] = -1;
  for (a = 0; a < vocab_size; a++) {
    // Words occuring less than min_count times will be discarded from the vocab
    if (vocab[a].cn < min_count) {
      vocab_size--;
      free(vocab[vocab_size].word);
    } else {
      // Hash will be re-computed, as after the sorting it is not actual
      hash = GetWordHash(vocab[a].word);
      while (vocab_hash[hash] != -1) hash = (hash + 1) % vocab_hash_size;
      vocab_hash[hash] = a;
    }
  }
  vocab = (struct vocab_word *)realloc(vocab, vocab_size * sizeof(struct vocab_word));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x3b71(%rip), %rdi      # 0x5180
addq $0x10, %rdi
movq 0x3b76(%rip), %rsi      # 0x5190
subq $0x1, %rsi
movl $0x10, %edx
leaq -0x4a(%rip), %rcx       # 0x15e0
callq 0x1150
movl $0x0, -0x4(%rbp)
cmpl $0x1dcd6500, -0x4(%rbp) # imm = 0x1DCD6500
jge 0x165c
movq 0x3b42(%rip), %rax      # 0x5188
movslq -0x4(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1636
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq 0x3b22(%rip), %rax      # 0x5190
jge 0x1729
movq 0x3b05(%rip), %rax      # 0x5180
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq 0x3a34(%rip), %rcx      # 0x50c4
cmpq %rcx, %rax
jge 0x16c7
movq 0x3af4(%rip), %rax      # 0x5190
addq $-0x1, %rax
movq %rax, 0x3ae9(%rip)      # 0x5190
movq 0x3ad2(%rip), %rax      # 0x5180
movq 0x3adb(%rip), %rcx      # 0x5190
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x10c0
jmp 0x1719
movq 0x3ab2(%rip), %rax      # 0x5180
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x1330
movl %eax, -0x8(%rbp)
movq 0x3a9c(%rip), %rax      # 0x5188
movl -0x8(%rbp), %ecx
cmpl $-0x1, (%rax,%rcx,4)
je 0x1709
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl $0x1dcd6500, %ecx       # imm = 0x1DCD6500
xorl %edx, %edx
divl %ecx
movl %edx, -0x8(%rbp)
jmp 0x16e5
movl -0x4(%rbp), %edx
movq 0x3a75(%rip), %rax      # 0x5188
movl -0x8(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x171b
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1663
movq 0x3a50(%rip), %rdi      # 0x5180
movq 0x3a59(%rip), %rsi      # 0x5190
shlq $0x4, %rsi
callq 0x1140
movq %rax, 0x3a39(%rip)      # 0x5180
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Leeheng86[P]word2vec/word2phrase.c
// Function: ReduceVocab()
void ReduceVocab() {
  int a, b = 0;
  unsigned int hash;
  for (a = 0; a < vocab_size; a++) if (vocab[a].cn > min_reduce) {
    vocab[b].cn = vocab[a].cn;
    vocab[b].word = vocab[a].word;
    b++;
  } else free(vocab[a].word);
  vocab_size = b;
  for (a = 0; a < vocab_hash_size; a++) vocab_hash[a] = -1;
  for (a = 0; a < vocab_size; a++) {
    // Hash will be re-computed, as it is not actual
    hash = GetWordHash(vocab[a].word);
    while (vocab_hash[hash] != -1) hash = (hash + 1) % vocab_hash_size;
    vocab_hash[hash] = a;
  }
  fflush(stdout);
  min_reduce++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq 0x3a1f(%rip), %rax      # 0x5190
jge 0x1824
movq 0x3a02(%rip), %rax      # 0x5180
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq 0x3935(%rip), %rcx      # 0x50c8
cmpq %rcx, %rax
jle 0x17f9
movq 0x39e1(%rip), %rax      # 0x5180
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq 0x39cc(%rip), %rax      # 0x5180
movslq -0x8(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x39b7(%rip), %rax      # 0x5180
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq 0x39a1(%rip), %rax      # 0x5180
movslq -0x8(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1814
movq 0x3980(%rip), %rax      # 0x5180
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x10c0
jmp 0x1816
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1766
movslq -0x8(%rbp), %rax
movq %rax, 0x3961(%rip)      # 0x5190
movl $0x0, -0x4(%rbp)
cmpl $0x1dcd6500, -0x4(%rbp) # imm = 0x1DCD6500
jge 0x185c
movq 0x3942(%rip), %rax      # 0x5188
movslq -0x4(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1836
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq 0x3922(%rip), %rax      # 0x5190
jge 0x18cd
movq 0x3909(%rip), %rax      # 0x5180
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x1330
movl %eax, -0xc(%rbp)
movq 0x38f3(%rip), %rax      # 0x5188
movl -0xc(%rbp), %ecx
cmpl $-0x1, (%rax,%rcx,4)
je 0x18b2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl $0x1dcd6500, %ecx       # imm = 0x1DCD6500
xorl %edx, %edx
divl %ecx
movl %edx, -0xc(%rbp)
jmp 0x188e
movl -0x4(%rbp), %edx
movq 0x38cc(%rip), %rax      # 0x5188
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1863
movq 0x36fc(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x10a0
movl 0x37e6(%rip), %eax      # 0x50c8
addl $0x1, %eax
movl %eax, 0x37dd(%rip)      # 0x50c8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Leeheng86[P]word2vec/word2phrase.c
// Function: ArgPos(char*, int, char**)
int ArgPos(char *str, int argc, char **argv) {
  int a;
  for (a = 1; a < argc; a++) if (!strcmp(str, argv[a])) {
    if (a == argc - 1) {
      printf("Argument missing for %s\n", str);
      exit(1);
    }
    return a;
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1f8a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x10f0
cmpl $0x0, %eax
jne 0x1f7d
movl -0x24(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1f75
movq -0x10(%rbp), %rsi
leaq 0x1193(%rip), %rdi      # 0x30f7
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x10d0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f91
jmp 0x1f7f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1f2a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/socket_creation_fork_error.c
// Function: main
int main() {
  struct rlimit l;
  l.rlim_cur = l.rlim_max = 10;
  check(setrlimit(RLIMIT_NOFILE, &l) == 0);

  libforks_ServerConn conn;
  check(libforks_start(&conn) == libforks_OK);

  while (true) {
    libforks_Result r = libforks_fork(
      conn,
      NULL, // pid_ptr
      NULL, // socket_fd_ptr
      NULL, // exit_fd_ptr
      child_main
    );
    if (r != libforks_OK) {
      check(r == libforks_SOCKET_CREATION_ERROR);
      check(errno == EMFILE);
      break;
    }
    check(r == libforks_OK);
  }

  check(libforks_stop(conn) == libforks_OK);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movq $0xa, -0x10(%rbp)
movq $0xa, -0x18(%rbp)
movl $0x7, %edi
leaq -0x18(%rbp), %rsi
callq 0x1180
cmpl $0x0, %eax
jne 0x1354
jmp 0x136c
leaq 0x2ca9(%rip), %rdi      # 0x4004
leaq 0x2cc4(%rip), %rsi      # 0x4026
movl $0x10, %edx
callq 0x1460
leaq -0x20(%rbp), %rdi
callq 0x1ac0
cmpl $0x0, %eax
jne 0x137c
jmp 0x1394
leaq 0x2cc6(%rip), %rdi      # 0x4049
leaq 0x2c9c(%rip), %rsi      # 0x4026
movl $0x13, %edx
callq 0x1460
jmp 0x1396
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0xfb(%rip), %r8         # 0x14a0
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x2290
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x13ff
cmpl $-0x3, -0x24(%rbp)
jne 0x13c1
jmp 0x13d9
leaq 0x2ca6(%rip), %rdi      # 0x406e
leaq 0x2c57(%rip), %rsi      # 0x4026
movl $0x1e, %edx
callq 0x1460
callq 0x1050
cmpl $0x18, (%rax)
jne 0x13e5
jmp 0x13fd
leaq 0x2ca6(%rip), %rdi      # 0x4092
leaq 0x2c33(%rip), %rsi      # 0x4026
movl $0x1f, %edx
callq 0x1460
jmp 0x1424
cmpl $0x0, -0x24(%rbp)
jne 0x1407
jmp 0x141f
leaq 0x2c94(%rip), %rdi      # 0x40a2
leaq 0x2c11(%rip), %rsi      # 0x4026
movl $0x22, %edx
callq 0x1460
jmp 0x1396
movq -0x20(%rbp), %rdi
callq 0x2520
cmpl $0x0, %eax
jne 0x1434
jmp 0x144c
leaq 0x2c78(%rip), %rdi      # 0x40b3
leaq 0x2be4(%rip), %rsi      # 0x4026
movl $0x25, %edx
callq 0x1460
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/test.c
// Function: listdevs
void listdevs(void)
{
    int dev;
    #define YESNO(x) ((x) ? "Yes" : "No ")

    for (dev = 0; dev < ASS_NumSoundCards; dev++) {
        printf("%d) %-15s PCM %s  CD %s  MIDI %s \n",
            dev, SoundDriver_GetName(dev),
            YESNO(SoundDriver_IsPCMSupported(dev)),
            YESNO(SoundDriver_IsCDSupported(dev)),
            YESNO(SoundDriver_IsMIDISupported(dev))
        );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x7, -0x4(%rbp)
jge 0x2aeb
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %edi
callq 0x2e00
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
callq 0x2d70
movl %eax, %edx
leaq 0xc840(%rip), %rax      # 0xf2ac
leaq 0xc835(%rip), %rcx      # 0xf2a8
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
callq 0x2da0
movl %eax, %edx
leaq 0xc81d(%rip), %rax      # 0xf2ac
leaq 0xc812(%rip), %rcx      # 0xf2a8
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x2dd0
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r8
movl %eax, %edi
leaq 0xc7eb(%rip), %r9       # 0xf2ac
leaq 0xc7e0(%rip), %rax      # 0xf2a8
cmpl $0x0, %edi
cmovneq %rax, %r9
leaq 0xc7af(%rip), %rdi      # 0xf285
movb $0x0, %al
callq 0x2050
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2a3f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/drivers.c
// Function: SoundDriver_PCM_ErrorString
const char * SoundDriver_PCM_ErrorString( int ErrorNumber )
{
	if (ASS_PCMSoundDriver < 0 || ASS_PCMSoundDriver >= ASS_NumSoundCards) {
		return "No sound driver selected.";
	}
	if (!SoundDriver_IsPCMSupported(ASS_PCMSoundDriver)) {
		return "Unsupported sound driver selected.";
	}
	return SoundDrivers[ASS_PCMSoundDriver].ErrorString(ErrorNumber);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, 0x1236e(%rip)     # 0x15200
jl 0x2e9d
cmpl $0x7, 0x12365(%rip)     # 0x15200
jl 0x2eaa
leaq 0xc40c(%rip), %rax      # 0xf2b0
movq %rax, -0x8(%rbp)
jmp 0x2eec
movl 0x12350(%rip), %edi     # 0x15200
callq 0x2d70
cmpl $0x0, %eax
jne 0x2ec7
leaq 0xc409(%rip), %rax      # 0xf2ca
movq %rax, -0x8(%rbp)
jmp 0x2eec
movslq 0x12332(%rip), %rcx     # 0x15200
leaq 0x1233b(%rip), %rax     # 0x15210
imulq $0xb8, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %edi
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/drivers.c
// Function: SoundDriver_CD_ErrorString
const char * SoundDriver_CD_ErrorString( int ErrorNumber )
{
	if (ASS_CDSoundDriver < 0 || ASS_CDSoundDriver >= ASS_NumSoundCards) {
		return "No sound driver selected.";
	}
	if (!SoundDriver_IsCDSupported(ASS_CDSoundDriver)) {
		return "Unsupported sound driver selected.";
	}
	return SoundDrivers[ASS_CDSoundDriver].ErrorString(ErrorNumber);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, 0x122a2(%rip)     # 0x15204
jl 0x2f6d
cmpl $0x7, 0x12299(%rip)     # 0x15204
jl 0x2f7a
leaq 0xc33c(%rip), %rax      # 0xf2b0
movq %rax, -0x8(%rbp)
jmp 0x2fbc
movl 0x12284(%rip), %edi     # 0x15204
callq 0x2da0
cmpl $0x0, %eax
jne 0x2f97
leaq 0xc339(%rip), %rax      # 0xf2ca
movq %rax, -0x8(%rbp)
jmp 0x2fbc
movslq 0x12266(%rip), %rcx     # 0x15204
leaq 0x1226b(%rip), %rax     # 0x15210
imulq $0xb8, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %edi
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/drivers.c
// Function: SoundDriver_MIDI_ErrorString
const char * SoundDriver_MIDI_ErrorString( int ErrorNumber )
{
	if (ASS_MIDISoundDriver < 0 || ASS_MIDISoundDriver >= ASS_NumSoundCards) {
		return "No sound driver selected.";
	}
	if (!SoundDriver_IsMIDISupported(ASS_MIDISoundDriver)) {
		return "Unsupported sound driver selected.";
	}
	return SoundDrivers[ASS_MIDISoundDriver].ErrorString(ErrorNumber);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, 0x121d6(%rip)     # 0x15208
jl 0x303d
cmpl $0x7, 0x121cd(%rip)     # 0x15208
jl 0x304a
leaq 0xc26c(%rip), %rax      # 0xf2b0
movq %rax, -0x8(%rbp)
jmp 0x308c
movl 0x121b8(%rip), %edi     # 0x15208
callq 0x2dd0
cmpl $0x0, %eax
jne 0x3067
leaq 0xc269(%rip), %rax      # 0xf2ca
movq %rax, -0x8(%rbp)
jmp 0x308c
movslq 0x1219a(%rip), %rcx     # 0x15208
leaq 0x1219b(%rip), %rax     # 0x15210
imulq $0xb8, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %edi
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_ErrorString
const char *FX_ErrorString
   (
   int ErrorNumber
   )

   {
   const char *ErrorString;

   switch( ErrorNumber )
      {
      case FX_Warning :
      case FX_Error :
         ErrorString = FX_ErrorString( FX_ErrorCode );
         break;

      case FX_Ok :
         ErrorString = "Fx ok.";
         break;

      case FX_ASSVersion :
         ErrorString = "Apogee Sound System Version " ASS_VERSION_STRING "  "
            "Programmed by Jim Dose\n"
            "(c) Copyright 1995 James R. Dose.  All Rights Reserved.\n";
         break;
		
      case FX_SoundCardError :
			ErrorString = SoundDriver_PCM_ErrorString(SoundDriver_PCM_GetError());
			break;

      case FX_InvalidCard :
         ErrorString = "Invalid Sound Fx device.";
         break;

      case FX_MultiVocError :
         ErrorString = MV_ErrorString( MV_Error );
         break;

      default :
         ErrorString = "Unknown Fx error code.";
         break;
      }

   return( ErrorString );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x2, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x6, %eax
ja 0x358a
movq -0x18(%rbp), %rax
leaq 0xbe01(%rip), %rcx      # 0xf328
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x1274e(%rip), %edi     # 0x15c84
callq 0x3500
movq %rax, -0x10(%rbp)
jmp 0x3595
leaq 0xbdfc(%rip), %rax      # 0xf344
movq %rax, -0x10(%rbp)
jmp 0x3595
leaq 0xbdf6(%rip), %rax      # 0xf34b
movq %rax, -0x10(%rbp)
jmp 0x3595
callq 0x2e30
movl %eax, %edi
callq 0x2e80
movq %rax, -0x10(%rbp)
jmp 0x3595
leaq 0xbe53(%rip), %rax      # 0xf3c7
movq %rax, -0x10(%rbp)
jmp 0x3595
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4490
movq %rax, -0x10(%rbp)
jmp 0x3595
leaq 0xbe4f(%rip), %rax      # 0xf3e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_EndLooping
int FX_EndLooping
   (
   int handle
   )

   {
   int status;

   status = MV_EndLooping( handle );
   if ( status == MV_Error )
      {
      FX_SetErrorCode( FX_MultiVocError );
      status = FX_Warning;
      }

   return( status );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x5350
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
jne 0x391d
movl $0x4, 0x1236e(%rip)     # 0x15c84
movl $0xfffffffe, -0x8(%rbp) # imm = 0xFFFFFFFE
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_SetPan
int FX_SetPan
   (
   int handle,
   int vol,
   int left,
   int right
   )

   {
   int status;

   status = MV_SetPan( handle, vol, left, right );
   if ( status == MV_Error )
      {
      FX_SetErrorCode( FX_MultiVocError );
      status = FX_Warning;
      }

   return( status );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x53f0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x396f
movl $0x4, 0x1231c(%rip)     # 0x15c84
movl $0xfffffffe, -0x14(%rbp) # imm = 0xFFFFFFFE
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_SetPitch
int FX_SetPitch
   (
   int handle,
   int pitchoffset
   )

   {
   int status;

   status = MV_SetPitch( handle, pitchoffset );
   if ( status == MV_Error )
      {
      FX_SetErrorCode( FX_MultiVocError );
      status = FX_Warning;
      }

   return( status );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x4d50
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x39b3
movl $0x4, 0x122d8(%rip)     # 0x15c84
movl $0xfffffffe, -0xc(%rbp) # imm = 0xFFFFFFFE
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_SetFrequency
int FX_SetFrequency
   (
   int handle,
   int frequency
   )

   {
   int status;

   status = MV_SetFrequency( handle, frequency );
   if ( status == MV_Error )
      {
      FX_SetErrorCode( FX_MultiVocError );
      status = FX_Warning;
      }

   return( status );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x4e40
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x39f3
movl $0x4, 0x12298(%rip)     # 0x15c84
movl $0xfffffffe, -0xc(%rbp) # imm = 0xFFFFFFFE
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_GetFrequency
int FX_GetFrequency
   (
   int handle,
   int *frequency
   )

   {
   int status;

   status = MV_GetFrequency( handle, frequency );
   if ( status == MV_Error )
      {
      FX_SetErrorCode( FX_MultiVocError );
      status = FX_Warning;
      }

   return( status );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x4eb0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x3a35
movl $0x4, 0x12256(%rip)     # 0x15c84
movl $0xfffffffe, -0x14(%rbp) # imm = 0xFFFFFFFE
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_PlayVOC
int FX_PlayVOC
   (
   char *ptr,
   unsigned int ptrlength,
   int pitchoffset,
   int vol,
   int left,
   int right,
   int priority,
   unsigned int callbackval
   )

   {
   int handle;

   handle = MV_PlayVOC( ptr, ptrlength, pitchoffset, vol, left, right,
      priority, callbackval );
   if ( handle < MV_Ok )
      {
      FX_SetErrorCode( FX_MultiVocError );
      handle = FX_Warning;
      }

   return( handle );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl 0x10(%rbp), %r10d
movl 0x18(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x6f00
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x3aa6
movl $0x4, 0x121e5(%rip)     # 0x15c84
movl $0xfffffffe, -0x20(%rbp) # imm = 0xFFFFFFFE
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_PlayLoopedVOC
int FX_PlayLoopedVOC
   (
   char *ptr,
   unsigned int ptrlength,
   int loopstart,
   int loopend,
   int pitchoffset,
   int vol,
   int left,
   int right,
   int priority,
   unsigned int callbackval
   )

   {
   int handle;

   handle = MV_PlayLoopedVOC( ptr, ptrlength, loopstart, loopend, pitchoffset,
      vol, left, right, priority, callbackval );
   if ( handle < MV_Ok )
      {
      FX_SetErrorCode( FX_MultiVocError );
      handle = FX_Warning;
      }

   return( handle );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movl 0x10(%rbp), %ebx
movl 0x18(%rbp), %r11d
movl 0x20(%rbp), %r10d
movl 0x28(%rbp), %eax
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x6f70
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x3b2d
movl $0x4, 0x1215e(%rip)     # 0x15c84
movl $0xfffffffe, -0x28(%rbp) # imm = 0xFFFFFFFE
movl -0x28(%rbp), %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_PlayWAV
int FX_PlayWAV
   (
   char *ptr,
   unsigned int ptrlength,
   int pitchoffset,
   int vol,
   int left,
   int right,
   int priority,
   unsigned int callbackval
   )

   {
   int handle;

   handle = MV_PlayWAV( ptr, ptrlength, pitchoffset, vol, left, right,
      priority, callbackval );
   if ( handle < MV_Ok )
      {
      FX_SetErrorCode( FX_MultiVocError );
      handle = FX_Warning;
      }

   return( handle );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl 0x10(%rbp), %r10d
movl 0x18(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x64f0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x3ba6
movl $0x4, 0x120e5(%rip)     # 0x15c84
movl $0xfffffffe, -0x20(%rbp) # imm = 0xFFFFFFFE
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_PlayVOC3D
int FX_PlayVOC3D
   (
   char *ptr,
   unsigned int ptrlength,
   int pitchoffset,
   int angle,
   int distance,
   int priority,
   unsigned int callbackval
   )

   {
   int handle;

   handle = MV_PlayVOC3D( ptr, ptrlength, pitchoffset, angle, distance,
      priority, callbackval );
   if ( handle < MV_Ok )
      {
      FX_SetErrorCode( FX_MultiVocError );
      handle = FX_Warning;
      }

   return( handle );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x6da0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x3c9a
movl $0x4, 0x11ff1(%rip)     # 0x15c84
movl $0xfffffffe, -0x20(%rbp) # imm = 0xFFFFFFFE
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_PlayWAV3D
int FX_PlayWAV3D
   (
   char *ptr,
   unsigned int ptrlength,
   int pitchoffset,
   int angle,
   int distance,
   int priority,
   unsigned int callbackval
   )

   {
   int handle;

   handle = MV_PlayWAV3D( ptr, ptrlength, pitchoffset, angle, distance,
      priority, callbackval );
   if ( handle < MV_Ok )
      {
      FX_SetErrorCode( FX_MultiVocError );
      handle = FX_Warning;
      }

   return( handle );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x69b0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x3d0a
movl $0x4, 0x11f81(%rip)     # 0x15c84
movl $0xfffffffe, -0x20(%rbp) # imm = 0xFFFFFFFE
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_PlayRaw3D
int FX_PlayRaw3D
   (
   char *ptr,
   unsigned int ptrlength,
   unsigned rate,
   int pitchoffset,
   int angle,
   int distance,
   int priority,
   unsigned int callbackval
   )

   {
   int handle;

   handle = MV_PlayRaw3D( ptr, ptrlength, rate, pitchoffset, angle, distance,
      priority, callbackval );
   if ( handle < MV_Ok )
      {
      FX_SetErrorCode( FX_MultiVocError );
      handle = FX_Warning;
      }

   return( handle );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl 0x10(%rbp), %r10d
movl 0x18(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x6b10
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x3d86
movl $0x4, 0x11f05(%rip)     # 0x15c84
movl $0xfffffffe, -0x20(%rbp) # imm = 0xFFFFFFFE
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_PlayRaw
int FX_PlayRaw
   (
   char *ptr,
   unsigned int length,
   unsigned rate,
   int pitchoffset,
   int vol,
   int left,
   int right,
   int priority,
   unsigned int callbackval
   )

   {
   int handle;

   handle = MV_PlayRaw( ptr, length, rate, pitchoffset,
      vol, left, right, priority, callbackval );
   if ( handle < MV_Ok )
      {
      FX_SetErrorCode( FX_MultiVocError );
      handle = FX_Warning;
      }

   return( handle );
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl 0x10(%rbp), %r11d
movl 0x18(%rbp), %r10d
movl 0x20(%rbp), %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x61c0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x3e02
movl $0x4, 0x11e89(%rip)     # 0x15c84
movl $0xfffffffe, -0x20(%rbp) # imm = 0xFFFFFFFE
movl -0x20(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)