LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/wc.c
// Function: main
int main(int argc, char **argv){
    struct wc_args *args = calloc(1, sizeof(struct wc_args));
    if(args == NULL){
        fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
        return 1;
    }
    args = parse_arg(args, argc, argv);
    for(int i = 0; i < args->fcount; i++){
        int fd = open(args->files[i], O_RDONLY);
        if(!strcmp(args->files[i], "-")){
            fd = STDIN_FILENO;
        }
        if(fd < 0){
            fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
            return 1;
        }
        /*if(args->byte_count){
            puts("byte count");
            printf("%zu\n", wc_get_byte_count(fd));
        }
        if(args->line_count){
            puts("line count");
            printf("%zu\n", wc_get_nl_count(fd));
        }
        if(args->word_count){
            puts("word count");
            printf("%zu\n", wc_get_word_count(fd));
        }*/
        printf("  %zu %zu %zu %s\n", wc_get_nl_count(fd), wc_get_word_count(fd), wc_get_byte_count(fd), args->files[i]);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x1080
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x176a
movq 0x28d1(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x10d0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x913(%rip), %rsi       # 0x206a
movb $0x0, %al
callq 0x10a0
movl $0x1, -0x4(%rbp)
jmp 0x1884
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x1200
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x187d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x10b0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x898(%rip), %rsi       # 0x2060
callq 0x1090
cmpl $0x0, %eax
jne 0x17d9
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x1826
movq 0x2812(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x10d0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x854(%rip), %rsi       # 0x206a
movb $0x0, %al
callq 0x10a0
movl $0x1, -0x4(%rbp)
jmp 0x1884
movl -0x20(%rbp), %edi
callq 0x1530
movq %rax, -0x50(%rbp)
movl -0x20(%rbp), %edi
callq 0x15f0
movq %rax, -0x48(%rbp)
movl -0x20(%rbp), %edi
callq 0x14c0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rdi
movq (%rax,%rdi,8), %r8
leaq 0x80a(%rip), %rdi       # 0x2072
movb $0x0, %al
callq 0x1050
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1785
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pencode-lab[P]Shoit/sendstream.c
// Function: open_data_source
static bool open_data_source(shoit_core_t *sender)                                                                                   
{                                                                                                                                    
    sender->fromFd = -1;                                                                                                             
    if(sender->iStream){/*data source is file of disk*/                                                                             
        sender->fromFd = 0; /*from stdin, you can use youself stream pipe*/
    }                                                                                                                                

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xf8(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1a4(%rax)
je 0x2921
movq -0x8(%rbp), %rax
movl $0x0, 0xf8(%rax)
movl $0x1, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ddrown[P]pretend-ntp/ntp-exit.c
// Function: main
int main(int argc, char *argv[]) {
  struct ntp_msg buf;
  int sock;
  struct sockaddr_in addr;

  if(argc < 3) {
    printf("%s [ip] [port]\n", argv[0]);
    exit(1);
  }
  if(inet_aton(argv[1], &addr.sin_addr) == INADDR_NONE) {
    printf("invalid ip %s\n", argv[1]);
    exit(1);
  }
  addr.sin_port = htons(strtoul(argv[2], NULL, 10));
  addr.sin_family = AF_INET;

  memset(&buf, 0, sizeof(buf));
  buf.version = NTP_VERS_4;
  buf.mode = NTP_MODE_PRIV;

  sock = socket(AF_INET, SOCK_DGRAM, 0);
  if (sock == -1) {
    perror_exit("socket");
  }
  sendto(sock, &buf, sizeof(buf), 0, &addr, sizeof(addr));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x126b
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xdaa(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1060
movl $0x1, %edi
callq 0x1100
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x54(%rbp), %rsi
addq $0x4, %rsi
callq 0x10a0
cmpl $-0x1, %eax
jne 0x12a5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xd80(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1060
movl $0x1, %edi
callq 0x1100
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x10f0
movzwl %ax, %edi
callq 0x1050
movw %ax, -0x52(%rbp)
movw $0x2, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1080
movb -0x40(%rbp), %al
andb $-0x39, %al
orb $0x20, %al
movb %al, -0x40(%rbp)
movb -0x40(%rbp), %al
andb $-0x8, %al
orb $0x7, %al
movb %al, -0x40(%rbp)
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x1120
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
jne 0x1314
leaq 0xd14(%rip), %rdi       # 0x2023
callq 0x1c10
movl -0x44(%rbp), %edi
leaq -0x54(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %r8
leaq -0x40(%rbp), %rsi
movl $0x30, %edx
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x1090
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/keiranrowan[P]tiny-core/./src/yes.c
// Function: main
int main(int argc, char **argv) {
    if (argc > 1 && argc < 3) {
        if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
            printf("yes [STRING]...\nPrints y or given string repeatedly\n");
        } else {
            for(;;) {
                printf("%s\n", argv[1]);
            }
        }
    } else {
        for(;;) {
            printf("y\n");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x11d0
cmpl $0x3, -0x8(%rbp)
jge 0x11d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe83(%rip), %rsi       # 0x2004
callq 0x1040
cmpl $0x0, %eax
je 0x11a4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe6d(%rip), %rsi       # 0x2007
callq 0x1040
cmpl $0x0, %eax
jne 0x11b4
leaq 0xe63(%rip), %rdi       # 0x200e
movb $0x0, %al
callq 0x1030
jmp 0x11ce
jmp 0x11b6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xe7e(%rip), %rdi       # 0x2043
movb $0x0, %al
callq 0x1030
jmp 0x11b6
jmp 0x11e2
jmp 0x11d2
leaq 0xe67(%rip), %rdi       # 0x2040
movb $0x0, %al
callq 0x1030
jmp 0x11d2
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/sha1/main.c
// Function: selftest
static int
selftest(void)
{
	SHA1_CTX ctx;
	uint8_t hbuf[20];
	char hbuf_hex[41];
	size_t i;
	size_t failures = 0;

	for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
		printf("Computing SHA1 of \"%s\"...", tests[i].s);
		SHA1_Init(&ctx);
		SHA1_Update(&ctx, (const uint8_t *)tests[i].s,
		    strlen(tests[i].s));
		SHA1_Final(hbuf, &ctx);
		hexify(hbuf, hbuf_hex, 20);
		if (strcmp(hbuf_hex, tests[i].o)) {
			printf(" FAILED!\n");
			printf("Computed SHA1: %s\n", hbuf_hex);
			printf("Correct SHA1:  %s\n", tests[i].o);
			failures++;
		} else {
			printf(" PASSED!\n");
		}
	}

	if (failures)
		return (1);
	else
		return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq $0x0, -0xc0(%rbp)
movq $0x0, -0xb8(%rbp)
cmpq $0x9, -0xb8(%rbp)
jae 0x168e
movq -0xb8(%rbp), %rcx
leaq 0x7ba3(%rip), %rax      # 0x90f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x4abd(%rip), %rdi      # 0x601b
movb $0x0, %al
callq 0x10d0
leaq -0x60(%rbp), %rdi
callq 0x17d0
movq -0xb8(%rbp), %rcx
leaq 0x7b74(%rip), %rax      # 0x90f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0xb8(%rbp), %rcx
leaq 0x7b55(%rip), %rax      # 0x90f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x10b0
movq -0xc8(%rbp), %rsi
movq %rax, %rdx
leaq -0x60(%rbp), %rdi
callq 0x1830
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3900
leaq -0x80(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0x14, %edx
callq 0x4b60
leaq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rcx
leaq 0x7afc(%rip), %rax      # 0x90f0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x1110
cmpl $0x0, %eax
je 0x1667
leaq 0x4a25(%rip), %rdi      # 0x6035
movb $0x0, %al
callq 0x10d0
leaq -0xb0(%rbp), %rsi
leaq 0x4a1a(%rip), %rdi      # 0x603f
movb $0x0, %al
callq 0x10d0
movq -0xb8(%rbp), %rcx
leaq 0x7ab6(%rip), %rax      # 0x90f0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
leaq 0x4a06(%rip), %rdi      # 0x6052
movb $0x0, %al
callq 0x10d0
movq -0xc0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc0(%rbp)
jmp 0x1675
leaq 0x49f7(%rip), %rdi      # 0x6065
movb $0x0, %al
callq 0x10d0
jmp 0x1677
movq -0xb8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb8(%rbp)
jmp 0x1531
cmpq $0x0, -0xc0(%rbp)
je 0x16a1
movl $0x1, -0x4(%rbp)
jmp 0x16a8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/sha1/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	SHA1_CTX ctx;
	uint8_t hbuf[20];
	size_t i;

	(void)cookie; /* UNUSED */

	/* Do the hashing. */
	SHA1_Init(&ctx);
	for (i = 0; i < nreps; i++)
		SHA1_Update(&ctx, buf, buflen);
	SHA1_Final(hbuf, &ctx);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x7c(%rbp), %rdi
callq 0x17d0
movq $0x0, -0x98(%rbp)
movq -0x98(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x17b1
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x7c(%rbp), %rdi
callq 0x1830
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x177f
leaq -0x90(%rbp), %rdi
leaq -0x7c(%rbp), %rsi
callq 0x3900
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../alg/sha1.c
// Function: SHA1_Pad
static void
SHA1_Pad(SHA1_CTX * ctx)
{
	uint8_t len[8];
	uint32_t r, plen;

	/*
	 * Convert length to a vector of bytes -- we do this now rather
	 * than later because the length will change after we pad.
	 */
	be32enc_vect(len, ctx->count, 8);

	/* Add 1--64 bytes so that the resulting length is 56 mod 64. */
	r = (ctx->count[1] >> 3) & 0x3f;
	plen = (r < 56) ? (56 - r) : (120 - r);
	SHA1_Update(ctx, PAD, (size_t)plen);

	/* Add the terminating bit-count. */
	SHA1_Update(ctx, len, 8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x14, %rsi
movl $0x8, %edx
callq 0x39d0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
cmpl $0x38, -0x14(%rbp)
jae 0x3985
movl $0x38, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3990
movl $0x78, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %edx
leaq 0x57da(%rip), %rsi      # 0x9180
callq 0x1830
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x1830
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../alg/sha1.c
// Function: libcperciva_HMAC_SHA1_Init
void
HMAC_SHA1_Init(HMAC_SHA1_CTX * ctx, const void * _k, size_t Klen)
{
	uint8_t pad[64];
	uint8_t khash[20];
	const uint8_t * K = _k;
	size_t i;

	/* If Klen > 64, the key is really SHA1(K). */
	if (Klen > 64) {
		SHA1_Init(&ctx->ictx);
		SHA1_Update(&ctx->ictx, K, Klen);
		SHA1_Final(khash, &ctx->ictx);
		K = khash;
		Klen = 20;
	}

	/* Inner SHA1 operation is SHA1(K xor [block of 0x36] || data). */
	SHA1_Init(&ctx->ictx);
	memset(pad, 0x36, 64);
	for (i = 0; i < Klen; i++)
		pad[i] ^= K[i];
	SHA1_Update(&ctx->ictx, pad, 64);

	/* Outer SHA1 operation is SHA1(K xor [block of 0x5c] || hash). */
	SHA1_Init(&ctx->octx);
	memset(pad, 0x5c, 64);
	for (i = 0; i < Klen; i++)
		pad[i] ^= K[i];
	SHA1_Update(&ctx->octx, pad, 64);

	/* Clean the stack. */
	insecure_memzero(khash, 20);
	insecure_memzero(pad, 64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x40, -0x18(%rbp)
jbe 0x3b16
movq -0x8(%rbp), %rdi
callq 0x17d0
movq -0x8(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1830
leaq -0x80(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3900
leaq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movq $0x14, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17d0
leaq -0x60(%rbp), %rdi
movl $0x36, %esi
movl $0x40, %edx
callq 0x10f0
movq $0x0, -0x90(%rbp)
movq -0x90(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3b82
movq -0x88(%rbp), %rax
movq -0x90(%rbp), %rcx
movzbl (%rax,%rcx), %edx
movq -0x90(%rbp), %rax
movzbl -0x60(%rbp,%rax), %ecx
xorl %edx, %ecx
movb %cl, -0x60(%rbp,%rax)
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0x3b3d
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x40, %edx
callq 0x1830
movq -0x8(%rbp), %rdi
addq $0x5c, %rdi
callq 0x17d0
leaq -0x60(%rbp), %rdi
movl $0x5c, %esi
movl $0x40, %edx
callq 0x10f0
movq $0x0, -0x90(%rbp)
movq -0x90(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3c04
movq -0x88(%rbp), %rax
movq -0x90(%rbp), %rcx
movzbl (%rax,%rcx), %edx
movq -0x90(%rbp), %rax
movzbl -0x60(%rbp,%rax), %ecx
xorl %edx, %ecx
movb %cl, -0x60(%rbp,%rax)
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0x3bbf
movq -0x8(%rbp), %rdi
addq $0x5c, %rdi
leaq -0x60(%rbp), %rsi
movl $0x40, %edx
callq 0x1830
leaq -0x80(%rbp), %rdi
movl $0x14, %esi
callq 0x3a30
leaq -0x60(%rbp), %rdi
movl $0x40, %esi
callq 0x3a30
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../alg/sha1.c
// Function: libcperciva_HMAC_SHA1_Final
void
HMAC_SHA1_Final(uint8_t digest[20], HMAC_SHA1_CTX * ctx)
{
	uint8_t ihash[20];

	/* Finish the inner SHA1 operation. */
	SHA1_Final(ihash, &ctx->ictx);

	/* Feed the inner hash to the outer SHA1 operation. */
	SHA1_Update(&ctx->octx, ihash, 20);

	/* Finish the outer SHA1 operation. */
	SHA1_Final(digest, &ctx->octx);

	/* Clean the stack. */
	insecure_memzero(ihash, 20);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3900
movq -0x10(%rbp), %rdi
addq $0x5c, %rdi
leaq -0x30(%rbp), %rsi
movl $0x14, %edx
callq 0x1830
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x5c, %rsi
callq 0x3900
leaq -0x30(%rbp), %rdi
movl $0x14, %esi
callq 0x3a30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/ast.c
// Function: astn_new
ast_n *astn_new(int kind, int s_kind, token t) {
	ast_n *node = calloc(1, sizeof(struct AST_NODE));
	node->kind = kind;

	switch (kind) {
		case DECL:
			node->dat.decl.kind = s_kind;
			break;
		case EXPR:
			node->dat.expr.kind = s_kind;
			break;
		case STMT:
			node->dat.stmt.kind = s_kind;
			break;
	}
	node->tok = t;

	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x3110
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x33a2
jmp 0x338e
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x33ae
jmp 0x3398
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x33ba
jmp 0x33c4
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x33c4
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x33c4
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movl $0x30, %edx
callq 0x3160
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/ast.c
// Function: astn_del
void astn_del(ast_n *node) {
	if (node == NULL)
		return;

	//note: don't delete symbols here
	switch (node->kind) {
		case DECL:
			astn_del(node->dat.decl.init);
			astn_del(node->dat.decl.block);
			astn_del(node->dat.decl.next);
			break;
		case EXPR:
			if (node->dat.expr.type != NULL)
				type_del(node->dat.expr.type);
			astn_del(node->dat.expr.left);
			astn_del(node->dat.expr.right);
			break;
		case STMT:
			if (node->dat.stmt.lbl != NULL)
				free(node->dat.stmt.lbl);
			astn_del(node->dat.stmt.expr);
			astn_del(node->dat.stmt.body);
			astn_del(node->dat.stmt.else_body);
			break;
	}
	astn_del(node->next);

	//Free node data type tags
	if (node->tok.dtype != NULL)
		type_del(node->tok.dtype);

	free(node);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3408
jmp 0x34f8
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x342e
jmp 0x3417
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x3457
jmp 0x3421
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x348b
jmp 0x34ca
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x33f0
jmp 0x34ca
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x346f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xfca0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x33f0
jmp 0x34ca
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x34a3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x33f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x34ef
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xfca0
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/err.c
// Function: c_error
void c_error(s_pos *pos, const char *msg, ...) {
	if (pos != NULL) {
		fprintf(stderr, "%s:%i:%i: ",
			pos->fname, pos->line, pos->col);
	}
	va_list args;
	va_start(args, msg);
	fputs("ERROR: ", stderr);
	vfprintf(stderr, msg, args);
	va_end(args);

	c_errflag = 1;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x38b8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3911
movq 0x13706(%rip), %rax     # 0x16ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
leaq 0xd792(%rip), %rsi      # 0x1109c
movb $0x0, %al
callq 0x3140
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq 0x136b7(%rip), %rax     # 0x16ff0
movq %rax, -0xe8(%rbp)
movq (%rax), %rsi
leaq 0xd75d(%rip), %rdi      # 0x110a7
callq 0x30f0
movq -0xe8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3210
movl $0x1, 0x13b34(%rip)     # 0x174a4
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/err.c
// Function: c_warn
void c_warn(s_pos *pos, const char *msg, ...) {
	if (pos != NULL) {
		fprintf(stderr, "%s:%i:%i: ",
			pos->fname, pos->line, pos->col);
	}
	va_list args;
	va_start(args, msg);
	fputs("WARNING: ", stderr);
	vfprintf(stderr, msg, args);
	va_end(args);

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x39b8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3a11
movq 0x13606(%rip), %rax     # 0x16ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
leaq 0xd692(%rip), %rsi      # 0x1109c
movb $0x0, %al
callq 0x3140
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq 0x135b7(%rip), %rax     # 0x16ff0
movq %rax, -0xe8(%rbp)
movq (%rax), %rsi
leaq 0xd665(%rip), %rdi      # 0x110af
callq 0x30f0
movq -0xe8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3210
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/eval.c
// Function: rankof
int rankof(int op) {
	switch (op) {
		case TOK_DEFINED:	return 13;
		case TOK_NOT:
		case TOK_TLD:		return 12;
		case TOK_ASR:
		case TOK_DIV:
		case TOK_MOD:		return 11;
		case TOK_ADD:
		case TOK_SUB:		return 10;
		case TOK_LSHIFT:
		case TOK_RSHIFT:	return 9;
		case TOK_GTH:
		case TOK_LTH:
		case TOK_GEQ:
		case TOK_LEQ:		return 8;
		case TOK_EQ: 
		case TOK_NEQ:		return 7;
		case TOK_AND:		return 6;
		case TOK_XOR:		return 5;
		case TOK_OR:		return 4;
		case TOK_LOGIC_AND:	return 3;
		case TOK_LOGIC_OR:	return 2;
		case TOK_QMK:		
		case TOK_COL:		return 1;
		case TOK_CMM:		return 0;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x30, %eax
ja 0x3b1e
movq -0x10(%rbp), %rax
leaq 0xd625(%rip), %rcx      # 0x110bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xd, -0x4(%rbp)
jmp 0x3b25
movl $0xc, -0x4(%rbp)
jmp 0x3b25
movl $0xb, -0x4(%rbp)
jmp 0x3b25
movl $0xa, -0x4(%rbp)
jmp 0x3b25
movl $0x9, -0x4(%rbp)
jmp 0x3b25
movl $0x8, -0x4(%rbp)
jmp 0x3b25
movl $0x7, -0x4(%rbp)
jmp 0x3b25
movl $0x6, -0x4(%rbp)
jmp 0x3b25
movl $0x5, -0x4(%rbp)
jmp 0x3b25
movl $0x4, -0x4(%rbp)
jmp 0x3b25
movl $0x3, -0x4(%rbp)
jmp 0x3b25
movl $0x2, -0x4(%rbp)
jmp 0x3b25
movl $0x1, -0x4(%rbp)
jmp 0x3b25
movl $0x0, -0x4(%rbp)
jmp 0x3b25
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/eval.c
// Function: is_unary
int is_unary(int op) {
	switch (op) {
		case TOK_DEFINED:
		case TOK_NOT:
		case TOK_TLD:
			return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x18, %eax
je 0x3b58
jmp 0x3b44
movl -0xc(%rbp), %eax
subl $0x21, %eax
je 0x3b58
jmp 0x3b4e
movl -0xc(%rbp), %eax
subl $0x32, %eax
jne 0x3b61
jmp 0x3b58
movl $0x1, -0x4(%rbp)
jmp 0x3b68
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/eval.c
// Function: do_calc
void do_calc(vector *ops, vector *vals) {
	int op = (long long)vector_pop(ops);
	int trs = (op == TOK_QMK) ? (long long)vector_pop(vals) : 0;
	int rhs = (!is_unary(op)) ? (long long)vector_pop(vals) : 0;
	int lhs = (long long)vector_pop(vals);
	long long res = do_op(op, lhs, rhs, trs);
	vector_push(vals, (void*)res);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10900
movl %eax, -0x14(%rbp)
cmpl $0xf, -0x14(%rbp)
jne 0x3dd1
movq -0x10(%rbp), %rdi
callq 0x10900
movq %rax, -0x30(%rbp)
jmp 0x3dd9
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x3dd9
movq -0x30(%rbp), %rax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
callq 0x3b30
cmpl $0x0, %eax
jne 0x3dfc
movq -0x10(%rbp), %rdi
callq 0x10900
movq %rax, -0x38(%rbp)
jmp 0x3e04
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x3e04
movq -0x38(%rbp), %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10900
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x3b70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x108d0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/eval.c
// Function: eval_constexpr_ast
int eval_constexpr_ast(ast_n *root, int *err) {
	int eflag_prev = c_errflag;
	int res = _eval_constexpr_ast(root, err);
	*err = !eflag_prev && c_errflag;
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x130fd(%rip), %rax     # 0x174a4
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41f0
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x19(%rbp)
jne 0x43d7
leaq 0x130d6(%rip), %rax     # 0x174a4
cmpl $0x0, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/gen.c
// Function: gen_numlabel
char *gen_numlabel(asm_f *f) {
	//Generate a label and store it in the map
	int num = f->lnum++;
	char *buf = malloc(16);
	snprintf(buf, 16, ".L%i", num);
	map_insert(&f->labels, buf, buf);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl 0x28(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x28(%rcx)
movl %eax, -0xc(%rbp)
movl $0x10, %edi
callq 0x3190
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x10, %esi
leaq 0xd0f9(%rip), %rdx      # 0x11528
movb $0x0, %al
callq 0x30d0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x104f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/gen.c
// Function: gen_expr
void gen_expr(asm_f *f, ast_n *n) {
	switch (n->dat.expr.kind) {
		case EXPR_ASSIGN:
			break;
		case EXPR_LOGIC_AND:
		case EXPR_LOGIC_OR:
			gen_expr_logic_andor(f, n);
			break;
		case EXPR_LOGIC_NOT:
			break;
		case EXPR_EQ:
		case EXPR_NEQ:
		case EXPR_GTH:
		case EXPR_LTH:
		case EXPR_GEQ:
		case EXPR_LEQ:
			gen_expr_cmp(f, n);
			break;
		case EXPR_AND:
		case EXPR_OR:
		case EXPR_XOR:
			gen_expr_bitwise(f, n);
			break;
		case EXPR_NOT:
			gen_expr(f, n->dat.expr.left);
			asmf_add_inst(f, mk_inst(INST_NOT, 1,
				mk_oprd(OPRD_REG, EAX)
			));
			break;
		case EXPR_ADD:
		case EXPR_SUB:
		case EXPR_MUL:
		case EXPR_DIV:
		case EXPR_MOD:
		case EXPR_LSHIFT:
		case EXPR_RSHIFT:
			//gen_expr_arith(
			break;
		case EXPR_CAST:
		case EXPR_REF:
			gen_expr_ref(f, n);
			break;
		case EXPR_DEREF:
			gen_expr_deref(f, n);
			break;
		case EXPR_POS:
		case EXPR_NEG:
		case EXPR_INC_PRE:
		case EXPR_DEC_PRE:
		case EXPR_ARRAY:
			gen_expr_array(f, n);
			break;
		case EXPR_CALL:
			gen_expr_call(f, n);
			break;
		case EXPR_MEMB:
		case EXPR_PTR_MEMB:
		case EXPR_INC_POST:
		case EXPR_DEC_POST:
		case EXPR_IDENT:
			//gen_expr_var
			break;
		case EXPR_CONST:
		case EXPR_STR:
			gen_expr_immd(f, n);
			break;
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x38(%rbp)
subq $0x26, %rax
ja 0x4a54
movq -0x38(%rbp), %rax
leaq 0xcae4(%rip), %rcx      # 0x11434
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x4a54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4480
jmp 0x4a54
jmp 0x4a54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4a60
jmp 0x4a54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4d80
jmp 0x4a54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x4920
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x63c0
movl $0x43, %edi
movl $0x1, %esi
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x6460
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
jmp 0x4a54
jmp 0x4a54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4fa0
jmp 0x4a54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4fb0
jmp 0x4a54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5080
jmp 0x4a54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5230
jmp 0x4a54
jmp 0x4a54
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x54c0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/gen.c
// Function: gen_expr_bitwise
void gen_expr_bitwise(asm_f *f, ast_n *n) {
	int bit_i = -1;
	switch (n->dat.expr.kind) {
		case EXPR_AND: bit_i = INST_AND; break;
		case EXPR_OR:  bit_i = INST_OR;  break;
		case EXPR_XOR: bit_i = INST_XOR; break;
	}

	//Perform bitwise operation
	gen_expr(f, n->dat.expr.left);
	asmf_add_inst(f, mk_inst(INST_PUSH, 1, mk_oprd(OPRD_REG, RAX)));
	gen_expr(f, n->dat.expr.right);
	asmf_add_inst(f, mk_inst(INST_POP, 1, mk_oprd(OPRD_REG, RBX)));
	asmf_add_inst(f, mk_inst(bit_i, 2, 
		mk_oprd(OPRD_REG, RAX),
		mk_oprd(OPRD_REG, RBX)
	));

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x9c(%rbp)
subl $0x5, %eax
je 0x4dd1
jmp 0x4dae
movl -0x9c(%rbp), %eax
subl $0x6, %eax
je 0x4dda
jmp 0x4dbb
movl -0x9c(%rbp), %eax
subl $0x7, %eax
jne 0x4de1
jmp 0x4dc8
movl $0x32, -0x14(%rbp)
jmp 0x4de1
movl $0x31, -0x14(%rbp)
jmp 0x4de1
movl $0x34, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x4920
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x63c0
movl $0x36, %edi
movl $0x1, %esi
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x6460
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x4920
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0xf, %edx
callq 0x63c0
movl $0x37, %edi
movl $0x1, %esi
leaq -0x58(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x6460
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xac(%rbp)
leaq -0x78(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x63c0
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0xf, %edx
callq 0x63c0
movl -0xac(%rbp), %edi
movl $0x2, %esi
leaq -0x78(%rbp), %rcx
leaq -0x98(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x38(%rsp)
movb $0x0, %al
callq 0x6460
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/gen.c
// Function: gen_expr_deref
void gen_expr_deref(asm_f *f, ast_n *n) {
	gen_expr(f, n->dat.expr.left);
	asmf_add_inst(f, mk_inst(INST_MOV, 2, 
		mk_oprd(OPRD_REG, RAX),
		mk_oprd_ex(OPRD_REG, RAX, DEREF, 0)
	));

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x4920
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x63c0
leaq -0x50(%rbp), %rdi
xorl %r8d, %r8d
movl $0x1, %ecx
movl %r8d, %esi
movl %r8d, %edx
callq 0x63f0
movl $0x3e, %edi
movl $0x2, %esi
leaq -0x30(%rbp), %rcx
leaq -0x50(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x38(%rsp)
movb $0x0, %al
callq 0x6460
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/gen.c
// Function: gen_expr_array
void gen_expr_array(asm_f *f, ast_n *n) {
	gen_expr(f, n->dat.expr.left);
	asmf_add_inst(f, mk_inst(INST_MOV, 2, 
		mk_oprd(OPRD_REG, RBX),
		mk_oprd(OPRD_REG, RAX)
	));

	ast_n *ofs = n->dat.expr.right;
	if (ofs->dat.expr.kind == EXPR_CONST) {
		if (ofs->dat.expr.sym->type->kind != TYPE_INT) {
			c_error(NULL, "Array offset must be an integer\n");
			return;
		}
		asmf_add_inst(f, mk_inst(INST_MOV, 2, 
			mk_oprd(OPRD_REG, RAX),
			mk_oprd_ex(OPRD_REG, RAX, DEREF_IMM, 0) //placeholder
		));
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x4920
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0xf, %edx
callq 0x63c0
leaq -0x50(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x63c0
movl $0x3e, %edi
movl $0x2, %esi
leaq -0x30(%rbp), %rcx
leaq -0x50(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x38(%rsp)
movb $0x0, %al
callq 0x6460
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpl $0x25, 0x8(%rax)
jne 0x521d
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x6, (%rax)
je 0x517b
xorl %eax, %eax
movl %eax, %edi
leaq 0xc3be(%rip), %rsi      # 0x1152d
movb $0x0, %al
callq 0x3880
jmp 0x521f
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x78(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x63c0
leaq -0x98(%rbp), %rdi
xorl %r8d, %r8d
movl $0x3, %ecx
movl %r8d, %esi
movl %r8d, %edx
callq 0x63f0
movl $0x3e, %edi
movl $0x2, %esi
leaq -0x78(%rbp), %rcx
leaq -0x98(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x38(%rsp)
movb $0x0, %al
callq 0x6460
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
jmp 0x521f
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/gen.c
// Function: gen_stmt_cmpd
void gen_stmt_cmpd(asm_f *f, ast_n *n) {
	ast_n *n_cur = n->next;
	while (n_cur != NULL) {
		switch (n_cur->kind) {
			case STMT: gen_stmt(f, n_cur); break;
			case DECL: gen_decl(f, n_cur); break;
		}
		n_cur = n_cur->next;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5536
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x551b
jmp 0x5502
movl -0x1c(%rbp), %eax
subl $0x2, %eax
jne 0x5528
jmp 0x550c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5540
jmp 0x5528
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4470
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x54ec
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/gen.c
// Function: gen_stmt_label
void gen_stmt_label(asm_f *f, ast_n *n) {
	//Copy the symbol name to a new string
	char *lsrc = n->dat.stmt.lbl; //here

	//If the label isn't already in the map, store it
	char *lbl = map_get(&f->labels, lsrc);
	if (lbl == NULL) {
		int len = strlen(lsrc);
		char *str = malloc(len+1);
		strncpy(str, lsrc, len);
		str[len] = '\0';

		//Store the copy
		map_insert(&f->labels, str, str);
		lbl = str;
	}

	asmf_add_inst(f, mk_label(lbl));
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x10460
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5e20
movq -0x18(%rbp), %rdi
callq 0x30b0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3190
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x3050
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x30(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x104f0
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x65a0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/gen.c
// Function: gen_stmt_goto
void gen_stmt_goto(asm_f *f, ast_n *n) {
	//Verify label exists in function scope
	symbol *fsym = f->fsym;
	char *lbl = NULL;
	if ((lbl = map_get(&fsym->labels, n->dat.stmt.lbl)) == NULL) {
		c_error(NULL, "Label '%s' used but not defined\n",
			n->dat.stmt.lbl);
		return;
	}

	asmf_add_inst(f, mk_inst(INST_JMP, 1,
		mk_oprd_label(lbl)
	));
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10460
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5eaf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0xb72e(%rip), %rsi      # 0x115d4
movb $0x0, %al
callq 0x3880
jmp 0x5f07
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x6420
movl $0x45, %edi
movl $0x1, %esi
leaq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x6460
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/gen.c
// Function: gen_stmt_return
void gen_stmt_return(asm_f *f, ast_n *n) {
	//TODO: check for matching return type
	if (n->dat.stmt.expr != NULL) 
		gen_expr(f, n->dat.stmt.expr);
	asmf_add_inst(f, mk_inst(INST_LEAVE, 0));
	asmf_add_inst(f, mk_inst(INST_RET, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x5f3c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x4920
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x42, %edi
xorl %esi, %esi
movb $0x0, %al
callq 0x6460
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x41, %edi
xorl %esi, %esi
movb $0x0, %al
callq 0x6460
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/gen.c
// Function: gen_text
void gen_text(asm_f *f, ast_n *n) {
	//Loop for each declaration and function definition
	ast_n *n_cur = n;
	while (n_cur != NULL) {
		if (n_cur->dat.decl.kind == DECL_STD) {
			gen_decl(f, n_cur);
		} else {
			gen_fdef(f, n_cur);
		}
		n_cur = n_cur->next;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x63b3
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x6398
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4470
jmp 0x63a5
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f90
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6378
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/inst.c
// Function: mk_oprd
oprd mk_oprd(int type, int val) {
	oprd o;
	o.type = type;
	o.val.ival = val;
	o.deref = NODEREF;
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, (%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/inst.c
// Function: mk_oprd_ex
oprd mk_oprd_ex(int type, int val, int deref, int ofs) {
	oprd o;
	o.type = type;
	o.val.ival = val;
	o.deref = deref;
	o.deref_ofs.ival = ofs;
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %r8d, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, (%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x8(%rdi)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rdi)
movl -0x10(%rbp), %ecx
movl %ecx, 0x18(%rdi)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/inst.c
// Function: mk_inst
inst_n *mk_inst(int op_id, int argc, ...) {
	inst_n *in = malloc(sizeof(struct INST));
	in->op = op_id;
	in->lbl = NULL;
	in->next = NULL;

	//Initialize operands
	va_list args;
	va_start(args, argc);
	for (int i=0; i<3; i++) {
		//Initialize other operands as blank
		if (i >= argc) {
			in->oprd[i].type = -1;
			continue;
		}
		in->oprd[i] = va_arg(args, oprd);
	}
	va_end(args);

	return in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x649b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x78, %edi
callq 0x3190
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jge 0x658b
movl -0x34(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x6540
movq -0x10(%rbp), %rax
addq $0x10, %rax
movslq -0x34(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x6580
movq -0x10(%rbp), %rax
addq $0x10, %rax
movslq -0x34(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x20, %rdx
movq %rdx, -0x28(%rbp)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6517
movq -0x10(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/inst.c
// Function: asmf_init
void asmf_init(asm_f *f) {
	//f->data = NULL;
	//f->data_cur = NULL;
	f->text = NULL;
	f->text_cur = NULL;
	f->cont_tgt = NULL;
	f->break_tgt = NULL;
	f->lnum = 0;
	map_init(&f->labels, 10);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl $0xa, %esi
callq 0x101b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/inst.c
// Function: asmf_close
void asmf_close(asm_f *f) {
	struct INST *cur = f->text;
	while (cur != NULL) {
		struct INST *next = cur->next;
		inst_del(cur);
		cur = next;
	}

	//Free labels
	for (int i=0; i<f->labels.max; i++) {
		if (f->labels.table[i] != NULL)
			free(f->labels.table[i]);
	}
	map_close(&f->labels);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x688d
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65e0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x6867
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x68d5
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x68c8
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3030
jmp 0x68ca
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6894
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x10240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/inst.c
// Function: asmf_add_inst
void asmf_add_inst(asm_f *f, inst_n *in) {
	if (f->text == NULL) {
		f->text = in;
		f->text_cur = in;
	} else {
		f->text_cur->next = in;
		f->text_cur = in;
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x691f
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x693b
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)