LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kisom[P]kam/stest.c
// Function: test_stack8
static void
test_stack8(void)
{
	uint8_t val;
	stack8	st;

	st = new_stack8();
	if (st == NULL) {
		errx(EX_OSERR, "FAILED: malloc failure");
	}

	push8(st, 1);
	push8(st, 2);
	if (2 != (val = pop8(st))) {
		fprintf(stderr,
		    "FAILED: should have received 2 from the stack.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}

	push8(st, 3);
	if (3 != (val = pop8(st))) {
		fprintf(stderr,
		    "FAILED: should have received 3 from the stack.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}
	if (1 != (val = pop8(st)))
		errx(EX_SOFTWARE,
		    "FAILED: should have received 1 from the stack.");
	if (!empty8(st))
		errx(EX_SOFTWARE,
		    "FAILED: stack should report empty.");
	push8(st, 5);
	push8(st, 5);
	destroy8(st);
	printf("stack8: OK\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x11a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x14fb
movl $0x47, %edi
leaq 0xb10(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x11f0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x11f0
movq -0x10(%rbp), %rdi
callq 0x1250
movb %al, -0x1(%rbp)
movzbl %al, %ecx
movl $0x2, %eax
cmpl %ecx, %eax
je 0x156d
movq 0x2ac2(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xadb(%rip), %rsi       # 0x201b
movb $0x0, %al
callq 0x1070
movq 0x2aaa(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movzbl -0x1(%rbp), %edx
leaq 0xaef(%rip), %rsi       # 0x204b
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x1090
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x11f0
movq -0x10(%rbp), %rdi
callq 0x1250
movb %al, -0x1(%rbp)
movzbl %al, %ecx
movl $0x3, %eax
cmpl %ecx, %eax
je 0x15d1
movq 0x2a5e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xabe(%rip), %rsi       # 0x2062
movb $0x0, %al
callq 0x1070
movq 0x2a46(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movzbl -0x1(%rbp), %edx
leaq 0xa8b(%rip), %rsi       # 0x204b
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x1250
movb %al, -0x1(%rbp)
movzbl %al, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x15fc
movl $0x46, %edi
leaq 0xa9d(%rip), %rsi       # 0x2092
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x12b0
cmpl $0x0, %eax
jne 0x161d
movl $0x46, %edi
leaq 0xaab(%rip), %rsi       # 0x20c1
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x11f0
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x11f0
movq -0x10(%rbp), %rdi
callq 0x12d0
leaq 0xa9b(%rip), %rdi       # 0x20e4
movb $0x0, %al
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kisom[P]kam/stest.c
// Function: test_stack16
static void
test_stack16(void)
{
	uint16_t val;
	stack16	st;

	st = new_stack16();
	if (st == NULL) {
		errx(EX_OSERR, "FAILED: malloc failure");
	}

	push16(st, 1);
	push16(st, 2);
	if (2 != (val = pop16(st))) {
		fprintf(stderr,
		    "FAILED: should have received 2 from the stack.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}

	push16(st, 3);
	if (3 != (val = pop16(st))) {
		fprintf(stderr,
		    "FAILED: should have received 3 from the stack.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}
	if (1 != pop16(st))
		errx(EX_SOFTWARE,
		    "FAILED: should have received 1 from the stack.");
	if (!empty16(st))
		errx(EX_SOFTWARE,
		    "FAILED: stack should report empty.");

	for (val = 0; val < 16000; val++)
		push16(st, val);

	destroy16(st);
	printf("stack16: OK\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1320
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x168b
movl $0x47, %edi
leaq 0x980(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1370
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x1370
movq -0x10(%rbp), %rdi
callq 0x13d0
movw %ax, -0x2(%rbp)
movzwl %ax, %ecx
movl $0x2, %eax
cmpl %ecx, %eax
je 0x16fe
movq 0x2931(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x94a(%rip), %rsi       # 0x201b
movb $0x0, %al
callq 0x1070
movq 0x2919(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movzwl -0x2(%rbp), %edx
leaq 0x95e(%rip), %rsi       # 0x204b
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x1090
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x1370
movq -0x10(%rbp), %rdi
callq 0x13d0
movw %ax, -0x2(%rbp)
movzwl %ax, %ecx
movl $0x3, %eax
cmpl %ecx, %eax
je 0x1763
movq 0x28cc(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x92c(%rip), %rsi       # 0x2062
movb $0x0, %al
callq 0x1070
movq 0x28b4(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movzwl -0x2(%rbp), %edx
leaq 0x8f9(%rip), %rsi       # 0x204b
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x13d0
movzwl %ax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x178b
movl $0x46, %edi
leaq 0x90e(%rip), %rsi       # 0x2092
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1430
cmpl $0x0, %eax
jne 0x17ac
movl $0x46, %edi
leaq 0x91c(%rip), %rsi       # 0x20c1
movb $0x0, %al
callq 0x1050
movw $0x0, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x3e80, %eax           # imm = 0x3E80
jge 0x17d8
movq -0x10(%rbp), %rdi
movzwl -0x2(%rbp), %esi
callq 0x1370
movw -0x2(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x2(%rbp)
jmp 0x17b2
movq -0x10(%rbp), %rdi
callq 0x1450
leaq 0x908(%rip), %rdi       # 0x20f0
movb $0x0, %al
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/dumpobj.c
// Function: dump_bytes
void dump_bytes(
    char *buf,
    int len)
{
    int             i,
                    j;

    for (i = 0; i < len; i += 8) {
        printf("\t%3.3o: ", i);
        for (j = i; j < len && j < i + 8; j++)
            printf("%3.3o ", buf[j] & 0xff);

        printf("%*s", (i + 8 - j) * 4, "");

        for (j = i; j < len && j < i + 8; j++) {
            int             c = buf[j] & 0xff;

            if (!isprint(c))
                c = '.';
            putchar(c);
        }

        putchar('\n');
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x15d9
movl -0x10(%rbp), %esi
leaq 0x1caa(%rip), %rdi      # 0x3176
movb $0x0, %al
callq 0x10b0
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x19(%rbp)
jge 0x14f7
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
addl $0x8, %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1500
jmp 0x152b
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %esi
andl $0xff, %esi
leaq 0x1c66(%rip), %rdi      # 0x317f
movb $0x0, %al
callq 0x10b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14d9
movl -0x10(%rbp), %esi
addl $0x8, %esi
subl -0x14(%rbp), %esi
shll $0x2, %esi
leaq 0x1c48(%rip), %rdi      # 0x3186
leaq 0x1ba5(%rip), %rdx      # 0x30ea
movb $0x0, %al
callq 0x10b0
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x1a(%rbp)
jge 0x1570
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
addl $0x8, %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x1579
jmp 0x15c1
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x18(%rbp)
callq 0x1190
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0x15ae
movl $0x2e, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0x1040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1552
movl $0xa, %edi
callq 0x1040
movl -0x10(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x10(%rbp)
jmp 0x14b6
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/dumpobj.c
// Function: trim
void trim(
    char *buf)
{
    char           *cp;

    for (cp = buf + strlen(buf); cp > buf; cp--)
        if (cp[-1] != ' ')
            break;
    *cp = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1090
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jbe 0x19d4
movq -0x10(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x20, %eax
je 0x19c4
jmp 0x19d4
jmp 0x19c6
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x19ab
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/dumpobj.c
// Function: add_gsdline
void add_gsdline(
    char *line)
{
    if (nr_gsds >= gsdsize || all_gsds == NULL) {
        gsdsize += 128;
        all_gsds = realloc(all_gsds, gsdsize * sizeof(char *));
        if (all_gsds == NULL) {
            fprintf(stderr, "Out of memory\n");
            exit(EXIT_FAILURE);
        }
    }

    all_gsds[nr_gsds++] = line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x374e(%rip), %eax      # 0x5150
cmpl 0x374c(%rip), %eax      # 0x5154
jge 0x1a14
cmpq $0x0, 0x3736(%rip)      # 0x5148
jne 0x1a71
movl 0x373a(%rip), %eax      # 0x5154
addl $0x80, %eax
movl %eax, 0x372f(%rip)      # 0x5154
movq 0x371c(%rip), %rdi      # 0x5148
movslq 0x3721(%rip), %rsi      # 0x5154
shlq $0x3, %rsi
callq 0x1130
movq %rax, 0x3705(%rip)      # 0x5148
cmpq $0x0, 0x36fd(%rip)      # 0x5148
jne 0x1a6f
movq 0x35a4(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1746(%rip), %rsi      # 0x31a4
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x1160
jmp 0x1a71
movq -0x8(%rbp), %rdx
movq 0x36cc(%rip), %rax      # 0x5148
movl 0x36ce(%rip), %ecx      # 0x5150
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x36c3(%rip)      # 0x5150
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/dumpobj.c
// Function: got_endgsd
void got_endgsd(
    char *cp,
    int len)
{
    int             i;

    (void)cp;
    (void)len;

    if (nr_gsds == 0) {
        return;
    }

    qsort(all_gsds, nr_gsds, sizeof(char *), compare_gsdlines);

    printf("GSD:\n");

    for (i = 0; i < nr_gsds; i++) {
        fputs(all_gsds[i], stdout);
        free(all_gsds[i]);
    }

    printf("ENDGSD\n");

    free(all_gsds);
    all_gsds = NULL;
    nr_gsds = 0;
    gsdsize = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, 0x322a(%rip)      # 0x5150
jne 0x1f2d
jmp 0x1fe2
movq 0x3214(%rip), %rdi      # 0x5148
movslq 0x3215(%rip), %rsi      # 0x5150
movl $0x8, %edx
leaq -0x77(%rip), %rcx       # 0x1ed0
callq 0x1060
leaq 0x13c1(%rip), %rdi      # 0x3314
movb $0x0, %al
callq 0x10b0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x31e6(%rip), %eax      # 0x5150
jge 0x1fa9
movq 0x31d5(%rip), %rax      # 0x5148
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x3056(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
callq 0x10d0
movq 0x31b7(%rip), %rax      # 0x5148
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1f61
leaq 0x136a(%rip), %rdi      # 0x331a
movb $0x0, %al
callq 0x10b0
movq 0x318a(%rip), %rdi      # 0x5148
callq 0x1030
movq $0x0, 0x317a(%rip) # 0x5148
movl $0x0, 0x3178(%rip)      # 0x5150
movl $0x0, 0x3172(%rip)      # 0x5154
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/dumpobj.c
// Function: got_text
void got_text(
    char *cp,
    int len)
{
    unsigned        addr = WORD(cp + 2);

    last_text_addr = addr;

    printf("TEXT ADDR=%o LEN=%o\n", last_text_addr, len - 4);

    dump_words(last_text_addr, cp + 4, len - 4);

    if (bin)
        dump_bin(last_text_addr, cp + 4, len - 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0xff, %eax
movq -0x8(%rbp), %rcx
movsbl 0x3(%rcx), %ecx
andl $0xff, %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, 0x3935(%rip)      # 0x5960
movl 0x392f(%rip), %esi      # 0x5960
movl -0xc(%rbp), %edx
subl $0x4, %edx
leaq 0x12e4(%rip), %rdi      # 0x3322
movb $0x0, %al
callq 0x10b0
movl 0x3915(%rip), %edi      # 0x5960
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movl -0xc(%rbp), %edx
subl $0x4, %edx
callq 0x15e0
cmpq $0x0, 0x30d2(%rip)      # 0x5138
je 0x2081
movl 0x38f2(%rip), %edi      # 0x5960
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movl -0xc(%rbp), %edx
subl $0x4, %edx
callq 0x1790
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro11/dumpobj.c
// Function: rad50name
void rad50name(
    char *cp,
    char *name)
{
    unrad50(WORD(cp), name);
    unrad50(WORD(cp + 2), name + 3);
    name[6] = 0;
    trim(name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
andl $0xff, %edi
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
shll $0x8, %eax
addl %eax, %edi
movq -0x10(%rbp), %rsi
callq 0x2e40
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %edi
andl $0xff, %edi
movq -0x8(%rbp), %rax
movsbl 0x3(%rax), %eax
andl $0xff, %eax
shll $0x8, %eax
addl %eax, %edi
movq -0x10(%rbp), %rsi
addq $0x3, %rsi
callq 0x2e40
movq -0x10(%rbp), %rax
movb $0x0, 0x6(%rax)
movq -0x10(%rbp), %rdi
callq 0x1980
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/ikonvert-serial/ikonvert-serial.c
// Function: initializeDevice
static void initializeDevice(void)
{
  if (isSerialDevice)
  {
    sendInitState = SEND_ALL_INIT_MESSAGES;
    sendNextInitCommand();
  }
  else
  {
    sendInitState = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testb $0x1, 0x9aa6(%rip)      # 0xca61
je 0x2fce
movl $0xe, 0x9ab9(%rip)      # 0xca80
callq 0x3900
jmp 0x2fd8
movl $0x0, 0x9aa8(%rip)      # 0xca80
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: new_bitset
bitset_t*
new_bitset(void) {
    bitset_t* bs    = NEW(bitset_t, 1);
    if (!bs)
        { return (NULL); }
    memset(bs, 0, sizeof(bitset_t));
    bs->nwords = _DEFWORDS;
    bs->nbits = _DEFBITS;
    bs->map  = bs->defmap;
    return (bs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x58, %edi
callq 0x38b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12b7
movq $0x0, -0x8(%rbp)
jmp 0x12f3
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x10b0
movq -0x10(%rbp), %rax
movw $0x8, (%rax)
movq -0x10(%rbp), %rax
movl $0x200, 0x4(%rax)       # imm = 0x200
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: dup_bitset
bitset_t*
dup_bitset(bitset_t const* bs) {
    if (!bs)
        { return (NULL); }
    bitset_t* nbs       = new_bitset();
    memcpy(nbs, bs, sizeof(bitset_t));
    if (bs->map == bs->defmap)
        { nbs->map = nbs->defmap; }
    else {
        size_t bs_size = nbs->nwords * sizeof(_SETTYPE);
        if (!(nbs->map = NEW(_SETTYPE, bs_size)))
            { return (NULL); }
        memcpy(nbs->map, bs->map, bs_size);
    }
    return (nbs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1370
movq $0x0, -0x8(%rbp)
jmp 0x1407
callq 0x1290
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x58, %edx
callq 0x1110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x13b2
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x13ff
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
shlq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
shlq $0x3, %rdi
callq 0x38b0
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x13e6
movq $0x0, -0x8(%rbp)
jmp 0x1407
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x1110
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: add_bitset
_SETTYPE
_add_bitset(bitset_t* bs, size_t n) {
    if (!bs || n < bs->nbits)
        { return (0); }
    if (adjust_bitset(bs, _ROUND(n)))
        { return (-1); }
    return (ADD_BITSET(bs, n));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1447
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jae 0x1454
movq $0x0, -0x8(%rbp)
jmp 0x14d6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
shrq $0x6, %rax
shrq $0x3, %rax
shlq $0x4, %rax
movzwl %ax, %esi
callq 0x14e0
cmpl $0x0, %eax
je 0x147f
movq $-0x1, -0x8(%rbp)
jmp 0x14d6
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x14a2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1420
movq %rax, -0x20(%rbp)
jmp 0x14ce
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x18(%rbp), %rdx
shrq $0x6, %rdx
orq (%rcx,%rdx,8), %rax
movq %rax, (%rcx,%rdx,8)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: adjust_bitset
static int
adjust_bitset(bitset_t* bs, unsigned short new_size) {
    if (!bs || new_size <= bs->nwords)
        { return (DONE); }
    int oldsize = _BYTE_SETTYPE(bs->nwords);

    bs->nwords = new_size;
    bs->nbits = new_size * _BITS_IN_WORD;

    if (bs->invert)
        { bs->siter = bs->nbits - 1; }

    _SETTYPE* chunk = NEW(_SETTYPE, _BYTE_SETTYPE(new_size));
    memset(chunk, 0, _BYTE_SETTYPE(new_size));

    if (!chunk)
        { return (ERROR); }
    if (bs->map == bs->defmap) {
        bs->map = chunk;
        memcpy(bs->map, bs->defmap, oldsize);
    }
    else {
        memcpy(chunk, bs->map, oldsize);
        FREE(bs->map);
        bs->map = chunk;
    }
    return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1509
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jg 0x1515
movl $0x0, -0x4(%rbp)
jmp 0x1607
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
shlq $0x3, %rax
movl %eax, -0x18(%rbp)
movw -0x12(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movzwl -0x12(%rbp), %eax
shlq $0x6, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x54(%rax)
je 0x155a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
movzwl -0x12(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
shlq $0x3, %rdi
callq 0x38b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movzwl -0x12(%rbp), %eax
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x10b0
cmpq $0x0, -0x20(%rbp)
jne 0x1596
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1607
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x15d2
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movslq -0x18(%rbp), %rdx
callq 0x1110
jmp 0x1600
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x18(%rbp), %rdx
callq 0x1110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1190
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: add_range_bitset
void
add_range_bitset(bitset_t* bs, size_t min, size_t max) {
    if (max <= min)
        { return; }
    for (size_t i = min; i < max; ++i)
        { ADD_BITSET(bs, i); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x1630
jmp 0x1697
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1697
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x1661
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1420
jmp 0x1689
movq -0x20(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1638
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: is_empty_bitset
bool
is_empty_bitset(bitset_t const* bs) {
    if (!bs)
        { return (true); }
    for (size_t i = 0; i < bs->nwords; ++i) {
        if (bs->map[i])
            { return (false); }
    }
    return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16b5
movb $0x1, -0x1(%rbp)
jmp 0x16fa
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x16f6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x16e6
movb $0x0, -0x1(%rbp)
jmp 0x16fa
jmp 0x16e8
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x16bd
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: eq_bitset
bool
eq_bitset(bitset_t const* b1, bitset_t const* b2) {
    if (!b1 || !b2)
        { return (!b1 && !b2); }
    for (size_t i = 0; (i < b1->nwords) && (i < b2->nwords); ++i) {
        if (b1->map[i] != b2->map[i])
            { return (false); }
    }
    if (b1->nwords != b2->nwords) {
        bitset_t const* max_bset = ((b1->nwords > b2->nwords) ? b1 : b2);
        int leading = MAX(b1->nwords, b2->nwords);
        for (size_t i = leading; i < max_bset->nwords; ++i) {
            if (max_bset->map[i] != 0)
                { return (false); }
        }
    }
    return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x172a
cmpq $0x0, -0x18(%rbp)
jne 0x1750
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x39(%rbp)
jne 0x1743
cmpq $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x187e
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x3a(%rbp)
jae 0x1783
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpq %rcx, %rax
setb %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x178c
jmp 0x17c7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x20(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x17b7
movb $0x0, -0x1(%rbp)
jmp 0x187e
jmp 0x17b9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1758
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
je 0x187a
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jle 0x17f9
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1801
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jle 0x1827
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x1831
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movzwl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x1878
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1868
movb $0x0, -0x1(%rbp)
jmp 0x187e
jmp 0x186a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x183f
jmp 0x187a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: op_bitset
bitset_t*
_op_bitset(int kind, bitset_t* rbs, bitset_t* lbs) {
    if (!rbs || (kind != _COMPL && !lbs))
        { return (NULL); }
    if (kind != _COMPL && (adjust_bitset(rbs, lbs->nwords)
            || adjust_bitset(lbs, rbs->nwords)))
        { return (NULL); }
    for (size_t i = 0; i < rbs->nwords; ++i) {
        switch (kind) {
            case _UNION:
                    rbs->map[i] |= lbs->map[i];
                    break;
            case _INTERSECT:
                    rbs->map[i] &= lbs->map[i];
                    break;
            case _DIFF:
                    rbs->map[i] = (rbs->map[i] ^ (rbs->map[i] & lbs->map[i]));
                    break;
            case _COMPL:
                    rbs->map[i] = ~rbs->map[i];
                    break;
        }
    }
    return (rbs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x18b7
cmpl $0x3, -0xc(%rbp)
je 0x18c4
cmpq $0x0, -0x20(%rbp)
jne 0x18c4
movq $0x0, -0x8(%rbp)
jmp 0x1a15
cmpl $0x3, -0xc(%rbp)
je 0x1901
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movzwl (%rax), %esi
callq 0x14e0
cmpl $0x0, %eax
jne 0x18f4
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movzwl (%rax), %esi
callq 0x14e0
cmpl $0x0, %eax
je 0x1901
movq $0x0, -0x8(%rbp)
jmp 0x1a15
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x1a0d
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0x19fa
movq -0x30(%rbp), %rax
leaq 0xa6cb(%rip), %rcx      # 0xc004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x19fa
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x19fa
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rsi
andq (%rcx,%rsi,8), %rax
xorq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x19fa
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
xorq $-0x1, %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x19fc
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1909
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: truncate_bitset
void
truncate_bitset(bitset_t* bs) {
    if (!bs)
        { return; }
    if (bs->map != bs->defmap) {
        FREE(bs->map);
        bs->map = bs->defmap;
        bs->nwords = _DEFWORDS;
        bs->nbits = _DEFBITS;
    }
    CLEAR_BITSET(bs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1a35
jmp 0x1a97
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
je 0x1a7b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1190
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movw $0x8, (%rax)
movq -0x8(%rbp), %rax
movl $0x200, 0x4(%rax)       # imm = 0x200
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: next_bitset
int
_next_bitset(bitset_t* bs) {
    if (!bs)
        { return (IT_NULL); }
    if (bs->invert) {
        while (bs->siter >= 0) {
            int next_val = (bs->siter)--;
            if (OP_BITSET(bs, next_val, &))
                { return (next_val); }
        }
    }
    else {
        while (bs->siter < (int)bs->nbits) {
            int next_val = (bs->siter)++;
            if (OP_BITSET(bs, next_val, &))
                { return (next_val); }
        }
    }
    return (IT_NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1abb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b88
movq -0x10(%rbp), %rax
testb $0x1, 0x54(%rax)
je 0x1b20
jmp 0x1ac7
movq -0x10(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jl 0x1b1e
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x50(%rcx)
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
andl $0x3f, %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1b1c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b88
jmp 0x1ac7
jmp 0x1b81
jmp 0x1b22
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x1b7f
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x50(%rcx)
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x18(%rbp), %ecx
andl $0x3f, %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1b7d
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b88
jmp 0x1b22
jmp 0x1b81
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: hash_bitset
_SETTYPE
hash_bitset(bitset_t const* bs) {
    if (!bs)
        { return (0); }
    _SETTYPE count = 0;
    //Don't matter if overflow occurs
    for (size_t i = 0; i < bs->nwords; ++i)
        { count += bs->map[i]; }
    return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1ba9
movq $0x0, -0x8(%rbp)
jmp 0x1bf7
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x1bef
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1bb9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: is_subset_bitset
bool
is_subset_bitset(bitset_t const* bset1, bitset_t const* bset2) {
    if (!bset1 || !bset2)
        { return (!bset2); }
    //The Empty set is the subset of every all set even the empty set
    unsigned short min = MIN(bset1->nwords, bset2->nwords);
    for (size_t i = 0; i < min; ++i) {
        if ((~bset1->map[i]) & bset2->map[i])
            { return (false); }
    }
    if (bset2->nwords > bset1->nwords) {
        for (size_t i = bset1->nwords; i < bset2->nwords; ++i) {
            if (bset2->map[i])
                { return (false); }
        }
    }
    return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1c1a
cmpq $0x0, -0x18(%rbp)
jne 0x1c2e
cmpq $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1d0e
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x1c4c
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x1c56
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movw %ax, -0x1a(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
cmpq %rcx, %rax
jae 0x1cb2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
xorq $-0x1, %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
je 0x1ca2
movb $0x0, -0x1(%rbp)
jmp 0x1d0e
jmp 0x1ca4
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1c65
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jle 0x1d0a
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x1d08
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1cf8
movb $0x0, -0x1(%rbp)
jmp 0x1d0e
jmp 0x1cfa
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1ccf
jmp 0x1d0a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: is_disjoint_bitset
bool
is_disjoint_bitset(bitset_t const* bset1, bitset_t const* bset2) {
    if (!bset1 || !bset2)
        { return (!(!bset1 && !bset2)); }
    unsigned short max = MAX(bset1->nwords, bset2->nwords);
    for (size_t i = 0; i < max; ++i) {
        if (bset1->map[i] & bset2->map[i])
            { return (false); }
    }
    return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1d3a
cmpq $0x0, -0x18(%rbp)
jne 0x1d62
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
jne 0x1d53
cmpq $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1de6
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jle 0x1d80
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x30(%rbp)
jmp 0x1d8a
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movw %ax, -0x1a(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
cmpq %rcx, %rax
jae 0x1de2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
je 0x1dd2
movb $0x0, -0x1(%rbp)
jmp 0x1de6
jmp 0x1dd4
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1d99
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: count_elt_bitset
size_t
count_elt_bitset(bitset_t const* bset) {
    static uint8_t bit_count[] = {
        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
        4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
    };
    if (!bset)
        { return (0); }
    size_t count = 0;
    for (size_t i = 0; i < _BYTE_SETTYPE(bset->nwords); ++i)
        { count += bit_count[((uint8_t*)bset->map)[i]]; }
    return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1e09
movq $0x0, -0x8(%rbp)
jmp 0x1e68
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
shlq $0x3, %rcx
cmpq %rcx, %rax
jae 0x1e60
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xf29a(%rip), %rax      # 0x110e0
movzbl (%rax,%rcx), %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1e19
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/bitset.c
// Function: print_bitset
void
print_bitset(bitset_t* bs) {
    printf("{");
    if (bs) {
        unsigned int iter_back = bs->siter;
        int i;
        while ((i = IT_NEXT(bs)) != IT_NULL)
            { printf("%d,", i); }
        bs->siter = iter_back;
    }
    printf("}\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xaf0e(%rip), %rdi      # 0xcd91
movb $0x0, %al
callq 0x1090
cmpq $0x0, -0x8(%rbp)
je 0x1ec9
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1aa0
movl %eax, -0x10(%rbp)
cmpl $-0x1, %eax
je 0x1ebf
movl -0x10(%rbp), %esi
leaq 0xa15e(%rip), %rdi      # 0xc014
movb $0x0, %al
callq 0x1090
jmp 0x1e9b
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
leaq 0xa148(%rip), %rdi      # 0xc018
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/vector.c
// Function: make_len_vector
static vector_t*
make_len_vector(size_t len) {
    vector_t* vect = NEW(vector_t, 1);
    if (!vect)
        { return (NULL_VECT); }
    memset(vect, 0, sizeof(vector_t));
    vect->body = NEW(void*, len);
    if (!vect->body) {
        FREE(vect);
        return (NULL_VECT);
    }
    vect->alloc = len;
    return (vect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x18, %edi
callq 0x38b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1f1b
movq $0x0, -0x8(%rbp)
jmp 0x1f73
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x10b0
movq -0x10(%rbp), %rdi
shlq $0x3, %rdi
callq 0x38b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1f5f
movq -0x18(%rbp), %rdi
callq 0x1190
movq $0x0, -0x8(%rbp)
jmp 0x1f73
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/vector.c
// Function: dup_vector
vector_t*
dup_vector(vector_t const* vect) {
    if (!vect)
        { return (NULL_VECT); }
    vector_t* new_vect = make_len_vector(vect->alloc);
    if (!new_vect)
        { return (NULL_VECT); }
    memcpy(new_vect->body, vect->body, sizeof(void*) * vect->alloc);
    return (new_vect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1f9d
movq $0x0, -0x8(%rbp)
jmp 0x1fe6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1ef0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1fbf
movq $0x0, -0x8(%rbp)
jmp 0x1fe6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
shlq $0x3, %rdx
callq 0x1110
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/vector.c
// Function: clear_vector
void
clear_vector(vector_t* vect) {
    if (!vect)
        { return; }
    memset(vect->body, 0, sizeof(void*) * vect->alloc);
    vect->index = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2035
jmp 0x205b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x10b0
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/vector.c
// Function: insert_vector
void
insert_vector(vector_t* vect, size_t offset, void* obj) {
    if (!vect)
        { return; }
    extend_vector(vect);
    if (offset >= vect->index)
        { vect->body[vect->index] = obj; }
    else {
        memmove(vect->body + offset + 1, vect->body + offset,
                sizeof(void*) * (vect->index - offset));
        vect->body[offset] = obj;
    }
    ++vect->index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2090
jmp 0x2120
movq -0x8(%rbp), %rdi
callq 0x2130
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x20c0
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
subq -0x10(%rbp), %rdx
shlq $0x3, %rdx
callq 0x1140
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/vector.c
// Function: extend_vector
static void
extend_vector(vector_t* vect) {
    size_t new_sz;
    if (vect->index >= vect->alloc) {
        new_sz = round_up(vect->index);
        void** new_body = REALLOC(vect->body, sizeof(void*) * new_sz);
        if (new_body) {
            vect->body = new_body;
            vect->alloc = new_sz;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x2197
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x37d0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
shlq $0x3, %rsi
callq 0x3ed0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2195
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2197
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/vector.c
// Function: erase_vector
void
erase_vector(vector_t* vect, size_t offset) {
    if (!vect || offset >= vect->index)
        { return; }
    if (offset + 1 != vect->index) {
        memmove(vect->body + offset, vect->body + offset + 1,
                sizeof(void*) * (vect->index - offset - 1));
    }
    --vect->index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x21c5
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x21c7
jmp 0x222a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x221a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $0x8, %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
subq -0x10(%rbp), %rdx
subq $0x1, %rdx
shlq $0x3, %rdx
callq 0x1140
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/vector.c
// Function: reverse_vector
void reverse_vector(vector_t* vect) {
    if (!vect)
        { return; }
    size_t middle = vect->index / 2;
    for (size_t i = 0; i < middle; ++i) {
        void* swap_data = vect->body[i];
        vect->body[i] = vect->body[vect->index - i - 1];
        vect->body[vect->index - i - 1] = swap_data;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2244
jmp 0x22cf
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shrq %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x22cf
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq -0x18(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq -0x18(%rbp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x225b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/vector.c
// Function: get_index_vector
int get_index_vector(vector_t* vect, void const* obj, int (*pred)()) {
    if (!vect)
        { return (-1); }
    for (size_t i = 0; i < SIZE_VECTOR(vect); ++i) {
        if (pred && !(*pred)(AT_VECTOR(vect, i), obj))
            { return (i); }
        if (!pred && (obj == AT_VECTOR(vect, i)))
            { return (i); }
    }
    return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2307
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2389
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2382
cmpq $0x0, -0x20(%rbp)
je 0x234d
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rdx
movq (%rax,%rdx,8), %rdi
movq -0x18(%rbp), %rsi
movb $0x0, %al
callq *%rcx
cmpl $0x0, %eax
jne 0x234d
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x2389
cmpq $0x0, -0x20(%rbp)
jne 0x2372
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x28(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x2372
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x2389
jmp 0x2374
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x230f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)