LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_17/sort.c
// Function: str_nth_blank_pos
size_t str_nth_blank_pos(const char *s, size_t n)
{
  size_t pos = 0;
  while (n && *s != '\0')
  {
    if (*s == ' ' || *s == '\t')
    {
      do
      {
        ++pos;
        ++s;
      } while (*s == ' ' || *s == '\t');

      --n;
    }
    else
    {
      ++pos;
      ++s;
    }
  }

  return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x1d00
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1d0c
jmp 0x1d91
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x1d24
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x1d74
jmp 0x1d26
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x1a(%rbp)
je 0x1d5f
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x1d26
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1d8c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1ce4
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_17/sort.c
// Function: substr
char *substr(const char *s, size_t start, size_t end)
{
  if (start > end)
  {
    return NULL;
  }

  const size_t len = end - start;
  char *dest = alloc(len + 1);

  for (size_t i = start; i < end && s[i] != '\0'; ++i)
  {
    *dest = s[i];
    ++dest;
  }
  *dest = '\0';

  return dest - len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x1dcb
movq $0x0, -0x8(%rbp)
jmp 0x1e60
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x1e70
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x39(%rbp)
jae 0x1e14
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1e1d
jmp 0x1e48
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1df0
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
xorl %ecx, %ecx
subq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_03/htoi.c
// Function: get_line
int get_line(char line[], int lim)
{
  char c;
  int i = 0;
  while (i < lim - 1 && (c = getchar()) != EOF && c != '\n')
  {
    line[i++] = c;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
jge 0x121a
callq 0x1060
movb %al, -0xd(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x15(%rbp)
je 0x121a
movsbl -0xd(%rbp), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1223
jmp 0x123d
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x11e6
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_03/htoi.c
// Function: htoi
int htoi(char hex[])
{
  int result = 0;

  int i = 0, len = strlen(hex);

  while (i < len)
  {
    if (hex[i] == '0' && (hex[i + 1] == 'x' || hex[i + 1] == 'X'))
    {
      i += 2;
    }

    int temp = tolower(hex[i]);

    if (isdigit(temp))
    {
      temp -= 48;
    }

    if (isalpha(temp) && temp <= 'f')
    {
      temp = temp - 'a' + 10;
    }

    if ((hex[i] >= '0' && hex[i] <= '9') || (hex[i] >= 'a' && hex[i] <= 'f') || (hex[i] >= 'A' && hex[i] <= 'F'))
    {
      result += temp * (int)pow(16, len - i - 1);
    }
    else
    {
      printf("Error: Not a valid hex value.\n Try this format: 0xHHHH, where H is a hex digit.\n");
    }

    ++i;
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x13ef
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jne 0x12d8
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x78, %eax
je 0x12cf
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x58, %eax
jne 0x12d8
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1070
movl %eax, -0x18(%rbp)
callq 0x1080
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x130f
movl -0x18(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x18(%rbp)
callq 0x1080
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x133b
cmpl $0x66, -0x18(%rbp)
jg 0x133b
movl -0x18(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x135d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x13a1
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x137f
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x66, %eax
jle 0x13a1
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x13d3
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x46, %eax
jg 0x13d3
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd 0xc4c(%rip), %xmm0      # 0x2008
callq 0x1030
movl -0x1c(%rbp), %eax
cvttsd2si %xmm0, %ecx
imull %ecx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x13e1
leaq 0xc39(%rip), %rdi       # 0x2013
movb $0x0, %al
callq 0x1050
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1286
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/use_after_free.c
// Function: main
int main(int argc, char *argv[]) {
  str container;

  container.foo.a = 0;
  if ((container.foo.b = (char *)malloc(256 * sizeof(char))) != NULL) {
    strcpy(container.foo.b, "Falut!");
    container.foo.b[0] = 'S';
    printf("%s\n", container.foo.b);
    free(container.foo.b);
    if (container.foo.b)
      container.foo.b[0] = 'S';
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x100, %edi            # imm = 0x100
callq 0x1060
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x11e3
movq -0x18(%rbp), %rdi
leaq 0xe58(%rip), %rsi       # 0x2004
callq 0x1040
movq -0x18(%rbp), %rax
movb $0x53, (%rax)
movq -0x18(%rbp), %rsi
leaq 0xe48(%rip), %rdi       # 0x200b
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rdi
callq 0x1030
cmpq $0x0, -0x18(%rbp)
je 0x11e1
movq -0x18(%rbp), %rax
movb $0x53, (%rax)
jmp 0x11e3
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/tests/test_matrix.c
// Function: print_matrix
static void print_matrix(const parasail_matrix_t *matrix) {
    int i = 0;
    int j = 0;
    const char *alphabet = NULL;
    alphabet = matrix->alphabet;

    printf("matrix '%s'\n", matrix->name);
    printf("  ");
    for (i=0; i<matrix->size; ++i) {
        printf("%4c", alphabet[i]);
    }
    printf("\n");
    for (j=0; j<matrix->length; ++j) {
        if (matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) {
            printf("%c ", alphabet[j]);
        }
        else {
            if (matrix->query != NULL) {
                printf("%c ", matrix->query[j]);
            }
            else {
                printf("* ");
            }
        }
        for (i=0; i<matrix->size; ++i) {
            printf("%4d", matrix->matrix[j*matrix->size + i]);
        }
        printf("\n");
    }
    printf("max = %d\n", matrix->max);
    printf("min = %d\n", matrix->min);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x30338(%rip), %rdi     # 0x359b4
movb $0x0, %al
callq 0x5070
leaq 0x7a3f(%rip), %rdi      # 0xd0c9
movb $0x0, %al
callq 0x5070
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x56c9
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x7a15(%rip), %rdi      # 0xd0cc
movb $0x0, %al
callq 0x5070
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5698
leaq 0x302ef(%rip), %rdi     # 0x359bf
movb $0x0, %al
callq 0x5070
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x34(%rcx), %eax
jge 0x57b3
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x5714
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x79c5(%rip), %rdi      # 0xd0d0
movb $0x0, %al
callq 0x5070
jmp 0x574f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x573f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x799a(%rip), %rdi      # 0xd0d0
movb $0x0, %al
callq 0x5070
jmp 0x574d
leaq 0x798e(%rip), %rdi      # 0xd0d4
movb $0x0, %al
callq 0x5070
jmp 0x574f
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x5797
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x18(%rdx), %ecx
addl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %esi
leaq 0x7952(%rip), %rdi      # 0xd0d7
movb $0x0, %al
callq 0x5070
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5756
leaq 0x30221(%rip), %rdi     # 0x359bf
movb $0x0, %al
callq 0x5070
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x56de
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
leaq 0x791a(%rip), %rdi      # 0xd0db
movb $0x0, %al
callq 0x5070
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0x790f(%rip), %rdi      # 0xd0e5
movb $0x0, %al
callq 0x5070
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/tests/test_matrix.c
// Function: print_mapper
static void print_mapper(const parasail_matrix_t *matrix) {
    int i = 0;
    const int *mapper = matrix->mapper;

    for (i=0; i<256; ++i) {
        if (i%16 == 0) printf("\n");
        printf("%5d", mapper[i]);
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x5861
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x583d
leaq 0x30189(%rip), %rdi     # 0x359bf
movb $0x0, %al
callq 0x5070
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x78a0(%rip), %rdi      # 0xd0ef
movb $0x0, %al
callq 0x5070
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5816
leaq 0x30157(%rip), %rdi     # 0x359bf
movb $0x0, %al
callq 0x5070
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webserver/functions.c
// Function: analyze_request
int analyze_request(char* request,char **req_page){
	if(request == NULL) return -1;//bad request
	int start=0;
	char *word;
	short flagGET=0,flagCON=0,flagHOST=0;//flagUA=0,flagACL=0,flagACE=0;
	while(start!=-1){
		word = NULL;
		start = nextWord(request,&word,start);//save word
		if(start == -2) break;//request was empty
		if( !strcmp(word,"GET") ){
			flagGET=1;
			start = nextWord(request,req_page,start);//save req_page
			free(word);
			word=NULL;
			start = nextWord(request,&word,start);//check protocol
			if( strcmp(word,"HTTP/1.1") ){
				free(word);
				break;
			}
		}
		else if( !strcmp(word,"Host:") ) flagHOST=1;
		//else if( !strcmp(word,"User-Agent:") ) flagUA=1;
		//else if( !strcmp(word,"Accept-Language:") ) flagACL=1;
		//else if( !strcmp(word,"Accept-Encoding:") ) flagACE=1;
		else if( !strcmp(word,"Connection:") ) flagCON=1;
		free(word);
	}

	//if(flagGET && flagCON && flagUA && flagHOST && flagACL && flagACE)
	if(flagGET && flagCON &&  flagHOST)
		return 0;//OK

	return -1;//error missing one header
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x29f3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2b25
movl $0x0, -0x1c(%rbp)
movw $0x0, -0x2a(%rbp)
movw $0x0, -0x2c(%rbp)
movw $0x0, -0x2e(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x2afa
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x28(%rbp), %rsi
callq 0x24a0
movl %eax, -0x1c(%rbp)
cmpl $-0x2, -0x1c(%rbp)
jne 0x2a3c
jmp 0x2afa
movq -0x28(%rbp), %rdi
leaq 0x15d0(%rip), %rsi      # 0x4017
callq 0x2190
cmpl $0x0, %eax
jne 0x2ab0
movw $0x1, -0x2a(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x24a0
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2030
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x28(%rbp), %rsi
callq 0x24a0
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x1582(%rip), %rsi      # 0x401b
callq 0x2190
cmpl $0x0, %eax
je 0x2aae
movq -0x28(%rbp), %rdi
callq 0x2030
jmp 0x2afa
jmp 0x2aec
movq -0x28(%rbp), %rdi
leaq 0x1569(%rip), %rsi      # 0x4024
callq 0x2190
cmpl $0x0, %eax
jne 0x2acd
movw $0x1, -0x2e(%rbp)
jmp 0x2aea
movq -0x28(%rbp), %rdi
leaq 0x1552(%rip), %rsi      # 0x402a
callq 0x2190
cmpl $0x0, %eax
jne 0x2ae8
movw $0x1, -0x2c(%rbp)
jmp 0x2aea
jmp 0x2aec
movq -0x28(%rbp), %rdi
callq 0x2030
jmp 0x2a0c
movswl -0x2a(%rbp), %eax
cmpl $0x0, %eax
je 0x2b1e
movswl -0x2c(%rbp), %eax
cmpl $0x0, %eax
je 0x2b1e
movswl -0x2e(%rbp), %eax
cmpl $0x0, %eax
je 0x2b1e
movl $0x0, -0x4(%rbp)
jmp 0x2b25
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webserver/functions.c
// Function: copy_page
char* copy_page(char *page,int* count){
	*count=0;
	FILE *fp = fopen(page,"r");
	int maxlen = 20;
	char c;
	char* cppage = malloc(20*sizeof(char));
	while( 1 ){
		if(*count == maxlen){
			maxlen*=2;
			cppage = realloc(cppage,maxlen*sizeof(char));
		}
		c = fgetc(fp);
		if( !feof(fp) )
			cppage[*count] = c;
		else{
			cppage[*count] = '\0';
			break;
		}
		(*count)++;
	}
	fclose(fp);
	cppage = realloc(cppage,(*count + 1)*sizeof(char));
	return cppage;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x14e1(%rip), %rsi      # 0x4036
callq 0x22a0
movq %rax, -0x18(%rbp)
movl $0x14, -0x1c(%rbp)
movl $0x14, %edi
callq 0x21e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x2b9b
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
shlq $0x0, %rsi
callq 0x2210
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2130
movb %al, -0x1d(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21a0
cmpl $0x0, %eax
jne 0x2bc8
movb -0x1d(%rbp), %dl
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0x2bd9
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x2be6
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2b73
movq -0x18(%rbp), %rdi
callq 0x20c0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x0, %rsi
callq 0x2210
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webserver/webserver.c
// Function: reqArray_init
void reqArray_init(reqArray** ra){
	(*ra) = malloc(sizeof(reqArray));
	(*ra)->fds = malloc(MAXR*sizeof(int));
	(*ra)->start = 0;
	(*ra)->end = -1;
	(*ra)->count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x21e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0xc8, %edi
callq 0x21e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webserver/webserver.c
// Function: place
void place(reqArray** ra,int fd){// place request in buffer
	pthread_mutex_lock(&mtx);
	while((*ra)->count>=MAXR){
		//printf("Pool found full\n");
		pthread_cond_wait(&cv_notfull,&mtx);
	}
	(*ra)->end = ((*ra)->end+1)%MAXR;
	(*ra)->fds[(*ra)->end] = fd;
	//printf("placed: %d\n",(*ra)->fds[(*ra)->end]);
	(*ra)->count++;
	pthread_mutex_unlock(&mtx);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x2c1a(%rip), %rdi      # 0x61d0
callq 0x2340
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x32, 0x8(%rax)
jl 0x35dd
leaq 0x2c29(%rip), %rdi      # 0x61f8
leaq 0x2bfa(%rip), %rsi      # 0x61d0
callq 0x20b0
jmp 0x35bb
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movl $0x32, %ecx
cltd
idivl %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %edx, 0x10(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
leaq 0x2ba2(%rip), %rdi      # 0x61d0
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webserver/webserver.c
// Function: obtain
int obtain(reqArray** ra){//get request from buffer
	int data;
	pthread_mutex_lock(&mtx);
	while( (*ra)->count <= 0 ){
		//printf("Pool found empty\n");
		pthread_cond_wait(&cv_notempty,&mtx);
	}
	data = (*ra)->fds[(*ra)->start];
	(*ra)->start = ( (*ra)->start + 1 ) % MAXR;
	(*ra)->count--;
	pthread_mutex_unlock(&mtx);
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2b7d(%rip), %rdi      # 0x61d0
callq 0x2340
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x8(%rax)
jg 0x367a
leaq 0x2bbc(%rip), %rdi      # 0x6228
leaq 0x2b5d(%rip), %rsi      # 0x61d0
callq 0x20b0
jmp 0x3658
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq 0xc(%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %eax
addl $0x1, %eax
movl $0x32, %ecx
cltd
idivl %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %edx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
leaq 0x2b05(%rip), %rdi      # 0x61d0
callq 0x21d0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webserver/webserver.c
// Function: threadExec
void *threadExec(void * rootdir){
	char *buf;
	char *page = NULL;
	char *ans = NULL;
	int anslen;
	char *rdir = (char *)rootdir;
	char *rdpage = NULL;
	int reqerr,localbytes;
	while( 1 ){//try to obtain a file desc and exit if u obtain -1
		buf = NULL;//malloc(10*sizeof(char));
		int data;
		data = obtain(&ra);
		//printf("thread: %d\n",data);
		pthread_cond_signal(&cv_notfull);
		if( data == -1) break;
		pthread_mutex_lock(&mtxcounter);
		totalrc++;
		pthread_mutex_unlock(&mtxcounter);
		while( (buf = read_request(data,BUFFERSIZE)) == NULL ){}//in case client haven't answered yet,repeat
		//printf("buf= %s\n",buf);
		reqerr = analyze_request(buf,&page);
		if(page != NULL){
			rdpage = (char *)malloc((strlen(page) + strlen(rdir) + 1)*sizeof(char));
			strcpy(rdpage,rdir);
			strcat(rdpage,page);
		}
		//printf("%s\n",rdpage);
		ans = create_answer(&anslen,rdpage,reqerr,&localbytes);
		pthread_mutex_lock(&mtxbytes);
		totalBytes += localbytes;
		pthread_mutex_unlock(&mtxbytes);
		//printf("%s\n",ans);
		write(data,ans,anslen);
		close(data);
		free(page);
		free(ans);
		free(rdpage);
		free(buf);
	}
	free(buf);
	printf("thread exiting...\n");
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x2b3d(%rip), %rdi      # 0x6258
callq 0x3640
movl %eax, -0x44(%rbp)
leaq 0x2ace(%rip), %rdi      # 0x61f8
callq 0x2160
cmpl $-0x1, -0x44(%rbp)
jne 0x373a
jmp 0x3859
leaq 0x2b1f(%rip), %rdi      # 0x6260
callq 0x2340
movl 0x2a7c(%rip), %eax      # 0x61c8
addl $0x1, %eax
movl %eax, 0x2a73(%rip)      # 0x61c8
leaq 0x2b04(%rip), %rdi      # 0x6260
callq 0x21d0
movl -0x44(%rbp), %edi
movl $0x80, %esi
callq 0x28e0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x377a
jmp 0x3761
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x29d0
movl %eax, -0x3c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x37d9
movq -0x18(%rbp), %rdi
callq 0x20d0
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20d0
movq -0x50(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x21e0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2070
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22e0
movq -0x38(%rbp), %rsi
movl -0x3c(%rbp), %edx
leaq -0x24(%rbp), %rdi
leaq -0x40(%rbp), %rcx
callq 0x2c20
movq %rax, -0x20(%rbp)
leaq 0x2a90(%rip), %rdi      # 0x6288
callq 0x2340
movl -0x40(%rbp), %eax
addl 0x29c6(%rip), %eax      # 0x61cc
movl %eax, 0x29c0(%rip)      # 0x61cc
leaq 0x2a75(%rip), %rdi      # 0x6288
callq 0x21d0
movl -0x44(%rbp), %edi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x20a0
movl -0x44(%rbp), %edi
callq 0x2140
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x38(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0x2030
jmp 0x370c
movq -0x10(%rbp), %rdi
callq 0x2030
leaq 0xac3(%rip), %rdi       # 0x432c
movb $0x0, %al
callq 0x2100
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/DEL.c
// Function: del_file
int del_file(const char *dir){
    DIR* dirp;
    struct dirent *dp;
    struct stat dir_stat;
    char dir_name[255];

    if(access(dir,F_OK)!=0){
        return 0;
    }
    if(stat(dir, &dir_stat)<0){
        perror("失败!\n");
        return -1;
    } 
    if(S_ISREG(dir_stat.st_mode)){
        remove(dir);
    }
    else{
        perror("error!\n");
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1080
cmpl $0x0, %eax
je 0x1378
movl $0x0, -0x4(%rbp)
jmp 0x13d2
movq -0x10(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1060
cmpl $0x0, %eax
jge 0x13a2
leaq 0xc70(%rip), %rdi       # 0x2004
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13d2
movl -0x98(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x13bf
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x13cb
leaq 0xc47(%rip), %rdi       # 0x200d
callq 0x1090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/DEL.c
// Function: main
int main(int argc, char** argv){
    char lines[argc+1][255];
    predealLine(argc, argv, lines);

    if((strcmp("DEL",lines[0])==0)||(strcmp("del",lines[0])==0)){
        for(int i=1;i<argc;i++){
            del_file(lines[i]);
        }
    }
    else{
        perror("error after lines\n");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %rdx    # imm = 0x1FFFFFFFFF0
andq %rdx, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x30(%rbp)
movq %rdx, %rsp
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x11b0
movq -0x30(%rbp), %rsi
leaq 0xbd0(%rip), %rdi       # 0x2015
callq 0x1050
cmpl $0x0, %eax
je 0x1464
movq -0x30(%rbp), %rsi
leaq 0xbbf(%rip), %rdi       # 0x2019
callq 0x1050
cmpl $0x0, %eax
jne 0x1497
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1495
movq -0x30(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0xff, %rax, %rax
addq %rax, %rdi
callq 0x1350
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x146b
jmp 0x14a3
leaq 0xb7f(%rip), %rdi       # 0x201d
callq 0x1090
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/pciffmanager/main.cpp
// Function: PCIFFManager::~PCIFFManager()
PCIFFManager::~PCIFFManager()
{
	DeleteObject(title);
	DeleteObject(wnd);
	DeleteObject(menubar);
	DeleteObject(menu_file);
	DeleteObject(statusbar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x4745(%rip), %rcx      # 0x9ab0
movq %rcx, (%rax)
movq 0x5c0(%rax), %rdi
callq 0x43b0
jmp 0x537c
movq -0x10(%rbp), %rax
movq 0x5b8(%rax), %rdi
callq 0x43b0
jmp 0x538e
movq -0x10(%rbp), %rax
movq 0x5c8(%rax), %rdi
callq 0x43b0
jmp 0x53a0
movq -0x10(%rbp), %rax
movq 0x5d8(%rax), %rdi
callq 0x43b0
jmp 0x53b2
movq -0x10(%rbp), %rax
movq 0x5d0(%rax), %rdi
callq 0x43b0
jmp 0x53c4
movq -0x10(%rbp), %rdi
addq $0x5e0, %rdi            # imm = 0x5E0
callq 0x4200
movq -0x10(%rbp), %rdi
callq 0x4220
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x56a0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kilobyte[P]colormatch/243-256.c
// Function: rgb_diff
static int rgb_diff(int x, int y)
{
    int rx = x>>16;
    int ry = y>>16;
    int gx = (x>>8)&0xff;
    int gy = (y>>8)&0xff;
    int bx = x&0xff;
    int by = y&0xff;
    return 2*sqrd(rx, ry)
         + 4*sqrd(gx, gy)
         + 3*sqrd(bx, by);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movl -0x10(%rbp), %eax
movzbl %cl, %edi
movzbl %al, %esi
callq 0x1340
shll %eax
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movb %al, %cl
movl -0x18(%rbp), %eax
movzbl %cl, %edi
movzbl %al, %esi
callq 0x1340
movl %eax, %ecx
movl -0x28(%rbp), %eax
shll $0x2, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %cl
movl -0x20(%rbp), %eax
movzbl %cl, %edi
movzbl %al, %esi
callq 0x1340
movl %eax, %ecx
movl -0x24(%rbp), %eax
imull $0x3, %ecx, %ecx
addl %ecx, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/sort_bucket/main.c
// Function: printArray
void printArray(int array[], int n){
    int i;
    for(i=0;i<n;i++){
        printf("%d ",array[i]);
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1192
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xe84(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1166
leaq 0xe6f(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/sort_bucket/main.c
// Function: main
int main(int argc, char **argv)
{
    int i;
    for(i=0;i<10;i++){
        nums[i]=rand()%100;
    }
    
    int j;
    for(j=0;j<10;j++){
        bucket[nums[j]]++;
    }
    
    printArray(nums,10);
    int k;
    for(k=0;k<100;k++){
        if(bucket[k]==1){
            printf("%d ",k);
        }
    }
	printf("\n");
    
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x11f9
callq 0x1040
movl $0x64, %ecx
cltd
idivl %ecx
movslq -0x14(%rbp), %rcx
leaq 0x2e65(%rip), %rax      # 0x4050
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11cd
movl $0x0, -0x18(%rbp)
cmpl $0xa, -0x18(%rbp)
jge 0x1237
movslq -0x18(%rbp), %rcx
leaq 0x2e3f(%rip), %rax      # 0x4050
movslq (%rax,%rcx,4), %rcx
leaq 0x2e64(%rip), %rax      # 0x4080
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x2e57(%rip), %rax      # 0x4080
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1200
leaq 0x2e12(%rip), %rdi      # 0x4050
movl $0xa, %esi
callq 0x1150
movl $0x0, -0x1c(%rbp)
cmpl $0x64, -0x1c(%rbp)
jge 0x1284
movslq -0x1c(%rbp), %rcx
leaq 0x2e20(%rip), %rax      # 0x4080
cmpl $0x1, (%rax,%rcx,4)
jne 0x1277
movl -0x1c(%rbp), %esi
leaq 0xd94(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x1279
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x124f
leaq 0xd7d(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yueyoum[P]termgif/get_target_window.c
// Function: target_window
Window target_window(Display *d)
{
    Window w;
    Window parent;
    Window root = None;
    Window *children;
    unsigned int nchildren;
    Status s;

    while(parent != root)
    {
        w = parent;
        s = XQueryTree(d, w, &root, &parent, &children, &nchildren);

        if(s) XFree(children);
    }

    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x2807
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x2c(%rbp), %r9
callq 0x2070
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x2805
movq -0x28(%rbp), %rdi
callq 0x20a0
jmp 0x27c4
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Env_find
bool Env_find(Env *env, const char *key, word *result) {
  if (env == NULL) {
    return false;
  }
  if (strcmp(env->name, key) == 0) {
    *result = env->value;
    return true;
  }
  return Env_find(env->prev, key, result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1571
movb $0x0, -0x1(%rbp)
jmp 0x15b5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10f0
cmpl $0x0, %eax
jne 0x159b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x15b5
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1550
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: AST_heap_free
void AST_heap_free(ASTNode *node) {
  if (!AST_is_heap_object(node)) {
    return;
  }
  if (AST_is_pair(node)) {
    AST_heap_free(AST_pair_car(node));
    AST_heap_free(AST_pair_cdr(node));
  }
  free((void *)Object_address(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17c0
testb $0x1, %al
jne 0x181b
jmp 0x185d
movq -0x8(%rbp), %rdi
callq 0x1870
testb $0x1, %al
jne 0x182a
jmp 0x184c
movq -0x8(%rbp), %rdi
callq 0x1890
movq %rax, %rdi
callq 0x1800
movq -0x8(%rbp), %rdi
callq 0x18b0
movq %rax, %rdi
callq 0x1800
movq -0x8(%rbp), %rdi
callq 0x1440
movq %rax, %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: AST_new_pair
ASTNode *AST_new_pair(ASTNode *car, ASTNode *cdr) {
  ASTNode *node = AST_heap_alloc(kPairTag, sizeof(Pair));
  AST_pair_set_car(node, car);
  AST_pair_set_cdr(node, cdr);
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x1780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1920
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1950
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: AST_new_symbol
ASTNode *AST_new_symbol(const char *str) {
  word data_length = strlen(str) + 1;
  ASTNode *node = AST_heap_alloc(kSymbolTag, sizeof(Symbol) + data_length);
  Symbol *s = AST_as_symbol(node);
  s->length = data_length;
  memcpy(s->cstr, str, data_length);
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movl $0x5, %edi
callq 0x1780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a40
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1110
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Buffer_alloc_writable
byte *Buffer_alloc_writable(size_t capacity) {
  byte *result = mmap(NULL, capacity, PROT_READ | PROT_WRITE,
                      MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
  assert(result != MAP_FAILED);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x1080
movq %rax, -0x10(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x10(%rbp)
je 0x1b50
jmp 0x1b6f
leaq 0x12c55(%rip), %rdi     # 0x147ac
leaq 0x12b45(%rip), %rsi     # 0x146a3
movl $0x12e, %edx            # imm = 0x12E
leaq 0x12c57(%rip), %rcx     # 0x147c1
callq 0x1090
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Buffer_init
void Buffer_init(Buffer *result, size_t capacity) {
  result->address = Buffer_alloc_writable(capacity);
  assert(result->address != MAP_FAILED);
  result->state = kWritable;
  result->len = 0;
  result->capacity = capacity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $-0x1, %rcx
cmpq %rcx, (%rax)
je 0x1bb5
jmp 0x1bd4
leaq 0x12c29(%rip), %rdi     # 0x147e5
leaq 0x12ae0(%rip), %rsi     # 0x146a3
movl $0x134, %edx            # imm = 0x134
leaq 0x12c34(%rip), %rcx     # 0x14803
callq 0x1090
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Buffer_deinit
void Buffer_deinit(Buffer *buf) {
  munmap(buf->address, buf->capacity);
  buf->address = NULL;
  buf->len = 0;
  buf->capacity = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x1140
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Buffer_ensure_capacity
void Buffer_ensure_capacity(Buffer *buf, word additional_capacity) {
  if (buf->len + additional_capacity <= buf->capacity) {
    return;
  }
  word new_capacity =
      max(buf->capacity * 2, buf->capacity + additional_capacity);
  byte *address = Buffer_alloc_writable(new_capacity);
  memcpy(address, buf->address, buf->len);
  int result = munmap(buf->address, buf->capacity);
  assert(result == 0 && "munmap failed");
  buf->address = address;
  buf->capacity = new_capacity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
ja 0x1dbb
jmp 0x1e5d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
shlq %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
addq -0x10(%rbp), %rsi
callq 0x1d60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x1110
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x1140
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x1e27
movb $0x1, %al
testb $0x1, %al
jne 0x1e25
jmp 0x1e27
jmp 0x1e46
leaq 0x12a06(%rip), %rdi     # 0x14834
leaq 0x1286e(%rip), %rsi     # 0x146a3
movl $0x15d, %edx            # imm = 0x15D
leaq 0x12a12(%rip), %rcx     # 0x14853
callq 0x1090
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Emit_mov_reg_imm32
void Emit_mov_reg_imm32(Buffer *buf, Register dst, int32_t src) {
  Buffer_write8(buf, kRexPrefix);
  Buffer_write8(buf, 0xc7);
  Buffer_write8(buf, modrm(3, dst, 0));
  Buffer_write32(buf, src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x48, %esi
callq 0x1e70
movq -0x8(%rbp), %rdi
movl $0xc7, %esi
callq 0x1e70
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x3, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x1fb0
movq -0x18(%rbp), %rdi
movzbl %al, %esi
callq 0x1e70
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1ec0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Emit_add_reg_imm32
void Emit_add_reg_imm32(Buffer *buf, Register dst, int32_t src) {
  Buffer_write8(buf, kRexPrefix);
  if (dst == kRax) {
    // Optimization: add eax, {imm32} can either be encoded as 05 {imm32} or 81
    // c0 {imm32}.
    Buffer_write8(buf, 0x05);
  } else {
    Buffer_write8(buf, 0x81);
    Buffer_write8(buf, modrm(3, dst, 0));
  }
  Buffer_write32(buf, src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x48, %esi
callq 0x1e70
cmpl $0x0, -0xc(%rbp)
jne 0x20b6
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x1e70
jmp 0x20ea
movq -0x8(%rbp), %rdi
movl $0x81, %esi
callq 0x1e70
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x3, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x1fb0
movq -0x18(%rbp), %rdi
movzbl %al, %esi
callq 0x1e70
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1ec0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Emit_sub_reg_imm32
void Emit_sub_reg_imm32(Buffer *buf, Register dst, int32_t src) {
  Buffer_write8(buf, kRexPrefix);
  if (dst == kRax) {
    // Optimization: sub eax, {imm32} can either be encoded as 2d {imm32} or 81
    // e8 {imm32}.
    Buffer_write8(buf, 0x2d);
  } else {
    Buffer_write8(buf, 0x81);
    Buffer_write8(buf, modrm(3, dst, 5));
  }
  Buffer_write32(buf, src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x48, %esi
callq 0x1e70
cmpl $0x0, -0xc(%rbp)
jne 0x2136
movq -0x8(%rbp), %rdi
movl $0x2d, %esi
callq 0x1e70
jmp 0x216d
movq -0x8(%rbp), %rdi
movl $0x81, %esi
callq 0x1e70
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x3, %edi
movl $0x5, %edx
movzbl %al, %esi
callq 0x1fb0
movq -0x18(%rbp), %rdi
movzbl %al, %esi
callq 0x1e70
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1ec0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Emit_shl_reg_imm8
void Emit_shl_reg_imm8(Buffer *buf, Register dst, int8_t bits) {
  Buffer_write8(buf, kRexPrefix);
  Buffer_write8(buf, 0xc1);
  Buffer_write8(buf, modrm(3, dst, 4));
  Buffer_write8(buf, bits);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movl $0x48, %esi
callq 0x1e70
movq -0x8(%rbp), %rdi
movl $0xc1, %esi
callq 0x1e70
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x3, %edi
movl $0x4, %edx
movzbl %al, %esi
callq 0x1fb0
movq -0x18(%rbp), %rdi
movzbl %al, %esi
callq 0x1e70
movq -0x8(%rbp), %rdi
movzbl -0xd(%rbp), %esi
callq 0x1e70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Emit_cmp_reg_imm32
void Emit_cmp_reg_imm32(Buffer *buf, Register left, int32_t right) {
  Buffer_write8(buf, kRexPrefix);
  if (left == kRax) {
    // Optimization: cmp rax, {imm32} can be encoded as 0x3d {imm32}
    Buffer_write8(buf, 0x3d);
  } else {
    Buffer_write8(buf, 0x81);
    Buffer_write8(buf, modrm(3, left, 7));
  }
  Buffer_write32(buf, right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x48, %esi
callq 0x1e70
cmpl $0x0, -0xc(%rbp)
jne 0x2376
movq -0x8(%rbp), %rdi
movl $0x3d, %esi
callq 0x1e70
jmp 0x23ad
movq -0x8(%rbp), %rdi
movl $0x81, %esi
callq 0x1e70
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x3, %edi
movl $0x7, %edx
movzbl %al, %esi
callq 0x1fb0
movq -0x18(%rbp), %rdi
movzbl %al, %esi
callq 0x1e70
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1ec0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Emit_address_disp8
void Emit_address_disp8(Buffer *buf, Register direct, Indirect indirect) {
  if (indirect.reg == kRsp) {
    Buffer_write8(buf, modrm(1, kIndexNone, direct));
    Buffer_write8(buf, sib(kRsp, kIndexNone, Scale1));
  } else {
    Buffer_write8(buf, modrm(1, indirect.reg, direct));
  }
  Buffer_write8(buf, disp8(indirect.disp));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x4, -0x8(%rbp)
jne 0x24b6
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %edi
movl $0x4, %esi
movzbl %al, %edx
callq 0x1fb0
movq -0x28(%rbp), %rdi
movzbl %al, %esi
callq 0x1e70
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x4, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x1f80
movq -0x20(%rbp), %rdi
movzbl %al, %esi
callq 0x1e70
jmp 0x24e2
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %eax
movb %al, %cl
movl -0x14(%rbp), %eax
movl $0x1, %edi
movzbl %cl, %esi
movzbl %al, %edx
callq 0x1fb0
movq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x1e70
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movsbl -0x4(%rbp), %edi
callq 0x2420
movq -0x38(%rbp), %rdi
movzbl %al, %esi
callq 0x1e70
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Emit_jcc
word Emit_jcc(Buffer *buf, Condition cond, int32_t offset) {
  Buffer_write8(buf, 0x0f);
  Buffer_write8(buf, 0x80 + cond);
  word pos = Buffer_len(buf);
  Buffer_write32(buf, disp32(offset));
  return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xf, %esi
callq 0x1e70
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x80, %eax
movzbl %al, %esi
callq 0x1e70
movq -0x8(%rbp), %rdi
callq 0x1c90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %edi
callq 0x2760
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x1ec0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Emit_jmp
word Emit_jmp(Buffer *buf, int32_t offset) {
  Buffer_write8(buf, 0xe9);
  word pos = Buffer_len(buf);
  Buffer_write32(buf, disp32(offset));
  return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0xe9, %esi
callq 0x1e70
movq -0x8(%rbp), %rdi
callq 0x1c90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x2760
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x1ec0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Emit_rsp_adjust
void Emit_rsp_adjust(Buffer *buf, word adjust) {
  if (adjust < 0) {
    Emit_sub_reg_imm32(buf, kRsp, -adjust);
  } else if (adjust > 0) {
    Emit_add_reg_imm32(buf, kRsp, adjust);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x28df
movq -0x8(%rbp), %rdi
xorl %eax, %eax
subq -0x10(%rbp), %rax
movl %eax, %edx
movl $0x4, %esi
callq 0x2100
jmp 0x28fc
cmpq $0x0, -0x10(%rbp)
jle 0x28fa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %edx
movl $0x4, %esi
callq 0x2080
jmp 0x28fc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)