LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Hazematman[P]BSP-Renderer/bsp.c
// Function: loadBspTextures
static void loadBspTextures(Bsp *bsp, void *texData, Palette *plt){
	// Read in number of textures
	memcpy(&bsp->numTextures, texData, sizeof(int32_t));
	bsp->textures = malloc(sizeof(Texture*)*bsp->numTextures);

	// For each texture read its offset and then read texture data
	int32_t *offsetData = texData + sizeof(int32_t);
	for(int i=0; i < bsp->numTextures; i++){
		int32_t offset = offsetData[i];

		void *texDefData = texData + offset;
		TextureDef texDef;
		memcpy(&texDef, texDefData, sizeof(TextureDef));

		// Load and convert the texture to RGB
		// TODO: deal with mipmaps
		bsp->textures[i] = readPltTex(texDefData + texDef.offset1, texDef.width, texDef.height, plt, texDef.name);
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x6666
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movl $0x28, %edx
callq 0x10d0
movq -0x30(%rbp), %rdi
movl -0x40(%rbp), %eax
addq %rax, %rdi
movl -0x48(%rbp), %esi
movl -0x44(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq -0x58(%rbp), %r8
callq 0x5d50
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x65f0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Hazematman[P]BSP-Renderer/bsp.c
// Function: renderAllBspFaces
void renderAllBspFaces(Bsp *bsp){
	glBindVertexArray(bsp->vaoId);
	for(int f=0; f < bsp->numFaces; f++){
		Face *face = &bsp->faces[f];
		if(face->glId == 0){
			continue;
		}

		glBindBuffer(GL_ARRAY_BUFFER, face->glId);

		Vert *vert = NULL;
		glVertexAttribPointer(
				0,
				3,
				GL_FLOAT,
				GL_FALSE,
				sizeof(Vert),
				&vert->position);
		glVertexAttribPointer(
				1,
				2,
				GL_FLOAT,
				GL_FALSE,
				sizeof(Vert),
				&vert->texCoord);

		bindTexture(face->texture);

		glDrawArrays(GL_TRIANGLE_FAN, 0, face->numVerts);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x5b4d(%rip), %rax      # 0xc800
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %edi
callq *%rax
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x6d9d
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x6cfa
jmp 0x6d8f
leaq 0x571f(%rip), %rax      # 0xc420
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %esi
movl $0x8892, %edi           # imm = 0x8892
callq *%rax
movq $0x0, -0x20(%rbp)
leaq 0x5a70(%rip), %rax      # 0xc790
movq (%rax), %rax
movq -0x20(%rbp), %r9
xorl %ecx, %ecx
movl $0x3, %esi
movl $0x1406, %edx           # imm = 0x1406
movl $0x20, %r8d
movl %ecx, %edi
callq *%rax
leaq 0x5a4c(%rip), %rax      # 0xc790
movq (%rax), %rax
movq -0x20(%rbp), %r9
addq $0xc, %r9
movl $0x1, %edi
movl $0x2, %esi
movl $0x1406, %edx           # imm = 0x1406
xorl %ecx, %ecx
movl $0x20, %r8d
callq *%rax
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6020
leaq 0x55c4(%rip), %rax      # 0xc340
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %edx
movl $0x6, %edi
xorl %esi, %esi
callq *%rax
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6cc5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Hazematman[P]BSP-Renderer/bsp.c
// Function: freeBsp
void freeBsp(Bsp *bsp){
	for(int i=0; i < bsp->numTextures; i++){
		freeTex(bsp->textures[i]);
	}
	for(int i=0; i < bsp->numFaces; i++){
		free(bsp->faces[i].verts);
	}
	free(bsp->faces);
	free(bsp->textures);
	free(bsp->verts);
	free(bsp->planes);
	free(bsp->texInfo);
	free(bsp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x6def
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6dc3
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x6e29
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x1160
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6df6
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1160
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1160
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1160
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1160
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1160
movq -0x8(%rbp), %rdi
callq 0x1160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Hazematman[P]BSP-Renderer/cam.c
// Function: makeCam
Cam *makeCam(){
	Cam *cam = malloc(sizeof(Cam));
	
	cam->pos = (vec3Float){0,0,0};
	cam->fwd = (vec3Float){0,0,-1};
	cam->angle = (vec3Float){0,0,0};
	cam->right = (vec3Float){1,0,0};
	cam->up = (vec3Float){0,1,0};
	
	return cam;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x3c, %edi
callq 0x1170
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x14(%rbp), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss 0x28f5(%rip), %xmm0     # 0x9880
movss %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0xc(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x2c(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movss 0x28a8(%rip), %xmm0     # 0x987c
movss %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x24(%rax)
movl -0x30(%rbp), %ecx
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
movss 0x2871(%rip), %xmm0     # 0x987c
movss %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x44(%rbp), %rcx
movq %rcx, 0x30(%rax)
movl -0x3c(%rbp), %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Hazematman[P]BSP-Renderer/cam.c
// Function: turnCam
void turnCam(Cam *cam, float anglex, float angley){
	cam->angle.x -= anglex;
	cam->angle.y += angley;
	cam->angle.x += PI/2.0f;
	if(cam->angle.x >= PI){
		cam->angle.x = PI;
	} else if(cam->angle.x <= 0){
		cam->angle.x = 0;
	}

	if(cam->angle.y > 2.0*PI){
		cam->angle.y = fabs(cam->angle.y)-2.0f*PI;
	} else if(cam->angle.y < -2.0f*PI){
		cam->angle.y = -(fabs(cam->angle.y)-2.0f*PI);
	}
	cam->angle.x -= PI/2.0f;
	updateLookAt(cam);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss -0xc(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x18(%rax)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
addss 0x1c(%rax), %xmm0
movss %xmm0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movss 0x282c(%rip), %xmm0     # 0x9928
addss 0x18(%rax), %xmm0
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm0
movss 0x280d(%rip), %xmm1     # 0x9924
ucomiss %xmm1, %xmm0
jb 0x712f
movq -0x8(%rbp), %rax
movss 0x27fc(%rip), %xmm0     # 0x9924
movss %xmm0, 0x18(%rax)
jmp 0x714a
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
ucomiss 0x18(%rax), %xmm0
jb 0x7148
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
jmp 0x714a
movq -0x8(%rbp), %rax
movss 0x1c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x27d1(%rip), %xmm1     # 0x9930
ucomisd %xmm1, %xmm0
jbe 0x7198
movq -0x8(%rbp), %rax
movss 0x1c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x27c7(%rip), %xmm1     # 0x9940
pand %xmm1, %xmm0
movsd 0x27ab(%rip), %xmm1     # 0x9930
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1c(%rax)
jmp 0x71f4
movq -0x8(%rbp), %rax
movss 0x2788(%rip), %xmm0     # 0x992c
ucomiss 0x1c(%rax), %xmm0
jbe 0x71f2
movq -0x8(%rbp), %rax
movss 0x1c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x2782(%rip), %xmm1     # 0x9940
pand %xmm1, %xmm0
movsd 0x2766(%rip), %xmm1     # 0x9930
subsd %xmm1, %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1c(%rax)
jmp 0x71f4
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm0
movss 0x2723(%rip), %xmm1     # 0x9928
subss %xmm1, %xmm0
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x7220
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Hazematman[P]BSP-Renderer/cam.c
// Function: updateLookAt
static void updateLookAt(Cam *cam){
	cam->angle.x += PI/2.0f;
	cam->fwd.x = sinf(cam->angle.x) * cosf(-cam->angle.y);
	cam->fwd.y = cosf(cam->angle.x);
	cam->fwd.z = sinf(cam->angle.x) * sinf(-cam->angle.y);
	cam->angle.x -= PI/2.0f;
	vec3Cross(&cam->right, &cam->fwd, &cam->up);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x26f0(%rip), %xmm0     # 0x9928
addss 0x18(%rax), %xmm0
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm0
callq 0x10e0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x1c(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
callq 0x10a0
movaps %xmm0, %xmm1
movss -0x10(%rbp), %xmm0
mulss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm0
callq 0x10a0
movq -0x8(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm0
callq 0x10e0
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x1c(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
callq 0x10e0
movaps %xmm0, %xmm1
movss -0xc(%rbp), %xmm0
mulss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm0
movss 0x2638(%rip), %xmm1     # 0x9928
subss %xmm1, %xmm0
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x24, %rdi
movq -0x8(%rbp), %rsi
addq $0xc, %rsi
movq -0x8(%rbp), %rdx
addq $0x30, %rdx
callq 0x6360
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Hazematman[P]BSP-Renderer/game.c
// Function: init
Error init(){
	if(SDL_Init(SDL_INIT_EVERYTHING) == -1){
		errMsg("Could not initialize SDL");
		return INIT_FAILURE;
	}

	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, BITS_PER_PIXEL);
	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, BITS_PER_PIXEL);
	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, BITS_PER_PIXEL);
	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, BITS_PER_PIXEL);
	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, STENCIL_BUFFER_SIZE);
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, GL_TRUE);
	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, DEPTH_BUFFER_SIZE);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, MAJOR_GL_VERSION);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, MINOR_GL_VERSION);
	screen = SDL_CreateWindow(WINDOW_TITLE,
			SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
			WINDOW_WIDTH, WINDOW_HEIGHT,
			SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);

	context = SDL_GL_CreateContext(screen);

	if(ogl_LoadFunctions() == ogl_LOAD_FAILED){
		errMsg("Failed to initalize OpenGL functions");
		return INIT_FAILURE;
	}

	initGL();
	initData();

	return NO_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xf231, %edi           # imm = 0xF231
callq 0x10f0
cmpl $-0x1, %eax
jne 0x73df
leaq 0x25a1(%rip), %rdi      # 0x996f
callq 0x7380
movl $0x1, -0x4(%rbp)
jmp 0x74e2
xorl %edi, %edi
movl $0x8, %esi
callq 0x11d0
movl $0x1, %edi
movl $0x8, %esi
callq 0x11d0
movl $0x2, %edi
movl $0x8, %esi
callq 0x11d0
movl $0x3, %edi
movl $0x8, %esi
callq 0x11d0
movl $0x7, %edi
movl $0x8, %esi
callq 0x11d0
movl $0x5, %edi
movl $0x1, %esi
callq 0x11d0
movl $0x6, %edi
movl $0x18, %esi
callq 0x11d0
movl $0x15, %edi
movl $0x1, %esi
callq 0x11d0
movl $0x11, %edi
movl $0x3, %esi
callq 0x11d0
movl $0x12, %edi
movl $0x3, %esi
callq 0x11d0
leaq 0x250f(%rip), %rdi      # 0x9988
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
movl $0x320, %ecx            # imm = 0x320
movl $0x258, %r8d            # imm = 0x258
movl $0x6, %r9d
movl %edx, %esi
callq 0x1050
movq %rax, 0x57bb(%rip)      # 0xcc58
movq 0x57b4(%rip), %rdi      # 0xcc58
callq 0x1070
movq %rax, 0x57b0(%rip)      # 0xcc60
movb $0x0, %al
callq 0x12f0
cmpl $0x0, %eax
jne 0x74d1
leaq 0x24d0(%rip), %rdi      # 0x9993
callq 0x7380
movl $0x1, -0x4(%rbp)
jmp 0x74e2
callq 0x7880
callq 0x7900
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Hazematman[P]BSP-Renderer/game.c
// Function: initGL
static void initGL(){
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);

	//glEnable(GL_CULL_FACE);
	//glFrontFace(GL_CW);

	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

	createShader(&prg, "data/vs.glsl", "data/fs.glsl");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xbe2, %edi            # imm = 0xBE2
leaq 0x4960(%rip), %rax      # 0xc1f0
callq *(%rax)
movl $0x302, %edi            # imm = 0x302
movl $0x303, %esi            # imm = 0x303
leaq 0x48ed(%rip), %rax      # 0xc190
callq *(%rax)
movl $0xb71, %edi            # imm = 0xB71
leaq 0x493f(%rip), %rax      # 0xc1f0
callq *(%rax)
movl $0x203, %edi            # imm = 0x203
leaq 0x4909(%rip), %rax      # 0xc1c8
callq *(%rax)
xorps %xmm2, %xmm2
movss 0x1fb0(%rip), %xmm3     # 0x987c
leaq 0x48cd(%rip), %rax      # 0xc1a0
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq *(%rax)
leaq 0x5386(%rip), %rdi      # 0xcc68
leaq 0x20de(%rip), %rsi      # 0x99c7
leaq 0x20e4(%rip), %rdx      # 0x99d4
callq 0x48b0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/pwrite1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);
	unlink(tmpfile);

	while (1) {
		assert(pwrite(fd, buf, BUFLEN, 0) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1326(%rip), %rax      # 0x42f0
movq %rax, -0x1030(%rbp)
movq 0x1320(%rip), %rax      # 0x42f8
movq %rax, -0x1028(%rbp)
movq 0x131a(%rip), %rax      # 0x4300
movq %rax, -0x1020(%rbp)
leaq -0x1030(%rbp), %rdi
callq 0x21b0
movl %eax, -0x1034(%rbp)
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2120
cmpl $0x0, -0x1034(%rbp)
jl 0x301d
jmp 0x303c
leaq 0x1259(%rip), %rdi      # 0x427d
leaq 0x125a(%rip), %rsi      # 0x4285
movl $0x12, %edx
leaq 0x125e(%rip), %rcx      # 0x4295
callq 0x2110
leaq -0x1030(%rbp), %rdi
callq 0x2080
movl -0x1034(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
xorl %eax, %eax
movl %eax, %ecx
callq 0x21c0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x306d
jmp 0x308c
leaq 0x1254(%rip), %rdi      # 0x42c8
leaq 0x120a(%rip), %rsi      # 0x4285
movl $0x16, %edx
leaq 0x120e(%rip), %rcx      # 0x4295
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3048
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: gottrace
int gottrace(void) {
	int	i;

	for (i=0; i<NTRACE; i++)
		if (Trace[i] != -1) return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
jge 0x23a8
movslq -0x8(%rbp), %rcx
leaq 0x1dfe4(%rip), %rax     # 0x20370
cmpl $-0x1, (%rax,%rcx,4)
je 0x239b
movl $0x1, -0x4(%rbp)
jmp 0x23af
jmp 0x239d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x237b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: report
void report(char *s, cell x) {
	int	i, j, o;

	o = set_outport(2);
	prints("*** error: ");
	prints(s);
	if (x != UNDEF) {
		prints(": ");
		Plimit = 100;
		prin(x);
		Plimit = 0;
	}
	nl();
	if (Files != NIL) {
		prints("*** file: ");
		printb(string(car(Files)));
		prints(", line: ");
		prints(ntoa(Line, 10));
		nl();
	}
	if (gottrace()) {
		prints("*** trace:");
		i = Tp;
		for (j=0; j<NTRACE; j++) {
			if (i >= NTRACE) i = 0;
			if (Trace[i] != -1) {
				prints(" ");
				printb(symname(vector(Symbols)[Trace[i]]));
			}
			i++;
		}
		nl();
	}
	set_outport(o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x2, %edi
callq 0x2580
movl %eax, -0x18(%rbp)
leaq 0x18fad(%rip), %rdi     # 0x1b390
callq 0x25a0
movq -0x8(%rbp), %rdi
callq 0x25a0
cmpl $-0x4, -0xc(%rbp)
je 0x241f
leaq 0x18fa6(%rip), %rdi     # 0x1b3a4
callq 0x25a0
movl $0x64, 0x1df8b(%rip)    # 0x20398
movl -0xc(%rbp), %edi
callq 0x25d0
movl $0x0, 0x1df79(%rip)     # 0x20398
leaq 0x19e5a(%rip), %rdi     # 0x1c280
callq 0x25a0
cmpl $-0x1, 0x1dd06(%rip)    # 0x20138
je 0x24a0
leaq 0x18f61(%rip), %rdi     # 0x1b39c
callq 0x25a0
movq 0x1df11(%rip), %rdi     # 0x20358
movq 0x1defa(%rip), %rax     # 0x20348
movq 0x1deeb(%rip), %rcx     # 0x20340
movslq 0x1dcdc(%rip), %rdx     # 0x20138
movslq (%rcx,%rdx,4), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x25a0
leaq 0x18f30(%rip), %rdi     # 0x1b3a7
callq 0x25a0
movl 0x1dcb2(%rip), %edi     # 0x20134
movl $0xa, %esi
callq 0x25f0
movq %rax, %rdi
callq 0x25a0
leaq 0x19de5(%rip), %rdi     # 0x1c280
callq 0x25a0
callq 0x2370
cmpl $0x0, %eax
je 0x2572
leaq 0x18efb(%rip), %rdi     # 0x1b3b0
callq 0x25a0
movl 0x1dea4(%rip), %eax     # 0x20364
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x2566
cmpl $0xa, -0x10(%rbp)
jl 0x24e1
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rcx
leaq 0x1de84(%rip), %rax     # 0x20370
cmpl $-0x1, (%rax,%rcx,4)
je 0x254f
leaq 0x19a2b(%rip), %rdi     # 0x1bf24
callq 0x25a0
movq 0x1de53(%rip), %rdi     # 0x20358
movq 0x1de3c(%rip), %rax     # 0x20348
movq 0x1de45(%rip), %rcx     # 0x20358
movq 0x1de2e(%rip), %rdx     # 0x20348
movslq 0x1dc1b(%rip), %rsi     # 0x2013c
movslq (%rdx,%rsi,4), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0x10(%rbp), %rsi
leaq 0x1de39(%rip), %rdx     # 0x20370
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x25a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x24ca
leaq 0x19d13(%rip), %rdi     # 0x1c280
callq 0x25a0
movl -0x18(%rbp), %edi
callq 0x2580
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: ntoa
char *ntoa(int x, int r) {
	static char	buf[200];
	int		i = 0, neg;
	char		*p = &buf[sizeof(buf)-1];
	char		d[] = "0123456789abcdefghijklmnopqrstuvwxyz";

	neg = x<0;
	*p = 0;
	while (x || 0 == i) {
		i++;
		p--;
		*p = d[abs(x % r)];
		x = x / r;
	}
	if (neg) {
		p--;
		*p = '-';
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x1e044(%rip), %rax     # 0x20650
addq $0xc7, %rax
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0x19d8f(%rip), %rsi     # 0x1c3b0
movl $0x25, %edx
callq 0x2150
cmpl $0x0, -0x4(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, %al
cmpl $0x0, -0x4(%rbp)
movb %al, -0x41(%rbp)
jne 0x2657
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x2660
jmp 0x269c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %edx, %eax
negl %eax
cmovnsl %eax, %edx
movslq %edx, %rax
movb -0x40(%rbp,%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, -0x4(%rbp)
jmp 0x2641
cmpl $0x0, -0x10(%rbp)
je 0x26b5
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x2d, (%rax)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: error
void error(char *s, cell x) {
	cell	n;

	n = assq(S_errtag, Glob);
	Handler = (NIL == n)? NIL: cadr(n);
	if (Handler != NIL) {
		n = assq(S_errval, Glob);
		if (n != NIL && cadr(n) == Handler)
			bindset(S_errval, mkstr(s, strlen(s)));
		longjmp(Errtag, 1);
	}
	report(s, x);
	longjmp(Restart, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x1dcc7(%rip), %edi     # 0x2039c
movl 0x1da69(%rip), %esi     # 0x20144
callq 0x27c0
movl %eax, -0x10(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x10(%rbp), %eax
jne 0x26f7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x2713
movq 0x1dc42(%rip), %rax     # 0x20340
movq 0x1dc43(%rip), %rcx     # 0x20348
movslq -0x10(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, 0x1da24(%rip)     # 0x20140
cmpl $-0x1, 0x1da1d(%rip)    # 0x20140
je 0x27a0
movl 0x1dc75(%rip), %edi     # 0x203a0
movl 0x1da13(%rip), %esi     # 0x20144
callq 0x27c0
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
je 0x278f
movq 0x1dbfa(%rip), %rax     # 0x20340
movq 0x1dbfb(%rip), %rcx     # 0x20348
movslq -0x10(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x1d9e2(%rip), %eax     # 0x20140
jne 0x278f
movl 0x1dc3a(%rip), %eax     # 0x203a0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2090
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x2880
movl -0x18(%rbp), %edi
movl %eax, %esi
callq 0x2830
leaq 0x1dc1a(%rip), %rdi     # 0x203b0
movl $0x1, %esi
callq 0x21a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x23c0
leaq 0x1dccd(%rip), %rdi     # 0x20480
movl $0x1, %esi
callq 0x21a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: mkstr
cell mkstr(char *s, int k) {
	cell	n;

	if (0 == k) return Nullstr;
	n = newvec(T_STRING, k+1);
	if (NULL == s) {
		memset(string(n), 0, k+1);
	}
	else {
		memcpy(string(n), s, k);
		string(n)[k] = 0;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x28a4
movl 0x1d8dc(%rip), %eax     # 0x20178
movl %eax, -0x4(%rbp)
jmp 0x2943
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl $0xffffffef, %edi       # imm = 0xFFFFFFEF
callq 0x3c40
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x28ee
movq 0x1da92(%rip), %rdi     # 0x20358
movq 0x1da7b(%rip), %rax     # 0x20348
movslq -0x18(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x20d0
jmp 0x293d
movq 0x1da63(%rip), %rdi     # 0x20358
movq 0x1da4c(%rip), %rax     # 0x20348
movslq -0x18(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2150
movq 0x1da39(%rip), %rax     # 0x20358
movq 0x1da22(%rip), %rcx     # 0x20348
movslq -0x18(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: readc
int readc(void) {
	int	c;

	if (Instr != NULL) {
		if (Rejected > -1) {
			c = Rejected;
			Rejected = -1;
			return c;
		}
		if (0 == *Instr) {
			return EOF;
		}
		else {
			return *Instr++;
		}
	}
	else {
		if (NULL == Ports[Inport])
			fatal("readc: input port is not open");
		return getc(Ports[Inport]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x1db58(%rip)     # 0x20558
je 0x2a5d
movsbl 0x1d74b(%rip), %eax     # 0x20154
cmpl $-0x1, %eax
jle 0x2a27
movsbl 0x1d73f(%rip), %eax     # 0x20154
movl %eax, -0x8(%rbp)
movb $-0x1, 0x1d735(%rip)    # 0x20154
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2a99
movq 0x1db2a(%rip), %rax     # 0x20558
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2a40
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2a99
movq 0x1db11(%rip), %rax     # 0x20558
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1db03(%rip)     # 0x20558
movsbl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2a99
movslq 0x1dae4(%rip), %rdx     # 0x20548
xorl %eax, %eax
leaq 0x1daf3(%rip), %rcx     # 0x20560
cmpq (%rcx,%rdx,8), %rax
jne 0x2a7f
leaq 0x18967(%rip), %rdi     # 0x1b3e1
callq 0x29a0
movslq 0x1dac2(%rip), %rcx     # 0x20548
leaq 0x1dad3(%rip), %rax     # 0x20560
movq (%rax,%rcx,8), %rdi
callq 0x2220
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: rejectc
void rejectc(int c) {
	if (Instr != NULL) {
		Rejected = c;
	}
	else {
		ungetc(c, Ports[Inport]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpq $0x0, 0x1da95(%rip)     # 0x20558
je 0x2ad0
movl -0x4(%rbp), %eax
movb %al, 0x1d686(%rip)      # 0x20154
jmp 0x2aea
movl -0x4(%rbp), %edi
movslq 0x1da6e(%rip), %rcx     # 0x20548
leaq 0x1da7f(%rip), %rax     # 0x20560
movq (%rax,%rcx,8), %rsi
callq 0x2190
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: mkport
cell mkport(int portno, cell type) {
	cell	n;
	int	pf;

	pf = Port_flags[portno];
	Port_flags[portno] |= LOCK_TAG;
	n = mkatom(portno, NIL);
	n = cons3(type, n, ATOM_TAG|PORT_TAG);
	Port_flags[portno] = pf;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x1dab7(%rip), %rax     # 0x20600
movsbl (%rax,%rcx), %eax
movl %eax, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x1daa5(%rip), %rax     # 0x20600
movsbl (%rax,%rcx), %eax
orl $0x40, %eax
movb %al, %dl
leaq 0x1da95(%rip), %rax     # 0x20600
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl $0x11, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0x1da5a(%rip), %rax     # 0x20600
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: alloc_nodepool
void alloc_nodepool(void) {
	Car = malloc(sizeof(cell) * NNODES);
	Cdr = malloc(sizeof(cell) * NNODES);
	Tag = malloc(NNODES);
	if (NULL == Car || NULL == Cdr || NULL == Tag)
		fatal("alloc_nodepool: out of physical memory");
	memset(Car, 0, sizeof(cell) * NNODES);
	memset(Cdr, 0, sizeof(cell) * NNODES);
	memset(Tag, 0, NNODES);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x100000, %edi         # imm = 0x100000
callq 0x2170
movq %rax, 0x1d51b(%rip)     # 0x20340
movl $0x100000, %edi         # imm = 0x100000
callq 0x2170
movq %rax, 0x1d512(%rip)     # 0x20348
movl $0x40000, %edi          # imm = 0x40000
callq 0x2170
movq %rax, 0x1d509(%rip)     # 0x20350
xorl %eax, %eax
cmpq 0x1d4f0(%rip), %rax     # 0x20340
je 0x2e68
xorl %eax, %eax
cmpq 0x1d4ed(%rip), %rax     # 0x20348
je 0x2e68
xorl %eax, %eax
cmpq 0x1d4ea(%rip), %rax     # 0x20350
jne 0x2e74
leaq 0x185cb(%rip), %rdi     # 0x1b43a
callq 0x29a0
movq 0x1d4c5(%rip), %rdi     # 0x20340
xorl %esi, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x20d0
movq 0x1d4ba(%rip), %rdi     # 0x20348
xorl %esi, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x20d0
movq 0x1d4af(%rip), %rdi     # 0x20350
xorl %esi, %esi
movl $0x40000, %edx          # imm = 0x40000
callq 0x20d0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: alloc_vecpool
void alloc_vecpool(void) {
	Vectors = malloc(sizeof(cell) * NVCELLS);
	if (NULL == Vectors)
		fatal("alloc_vecpool: out of physical memory");
	memset(Vectors, 0, sizeof(cell) * NVCELLS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x100000, %edi         # imm = 0x100000
callq 0x2170
movq %rax, 0x1d493(%rip)     # 0x20358
xorl %eax, %eax
cmpq 0x1d48a(%rip), %rax     # 0x20358
jne 0x2edc
leaq 0x1858a(%rip), %rdi     # 0x1b461
callq 0x29a0
movq 0x1d475(%rip), %rdi     # 0x20358
xorl %esi, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x20d0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: marklit
void marklit(cell p) {
	int	i, k, op;
	byte	*v, *m;

	k = stringlen(p);
	v = string(p);
	m = string(Obmap);
	for (i=0; i<k; ) {
		op = v[i];
		if (OP_QUOTE == op) {
			m[fetcharg(v, i+1)] = OBUSED;
			i += ISIZE1;
		}
		else if (OP_ARG == op || OP_PUSHVAL == op || OP_JMP == op ||
			 OP_BRF == op || OP_BRT == op || OP_CLOSURE == op ||
			 OP_MKENV == op || OP_ENTER == op || OP_ENTCOL == op ||
			 OP_SETARG == op || OP_SETREF == op || OP_MACRO == op)
		{
			i += ISIZE1;
		}
		else if (OP_REF == op || OP_CPARG == op || OP_CPREF == op) {
			i += ISIZE2;
		}
		else {
			i += ISIZE0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x1d44a(%rip), %rax     # 0x20358
movq 0x1d433(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq 0x1d429(%rip), %rax     # 0x20358
movq 0x1d412(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq 0x1d408(%rip), %rax     # 0x20358
movq 0x1d3f1(%rip), %rcx     # 0x20348
movslq 0x1d1fa(%rip), %rdx     # 0x20158
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x309a
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x10(%rbp)
movl $0x5, %eax
cmpl -0x10(%rbp), %eax
jne 0x2fdc
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
movq -0x18(%rbp), %rdx
movl -0x8(%rbp), %esi
addl $0x1, %esi
addl $0x1, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
movb $0x2, (%rax,%rcx)
movl -0x8(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x8(%rbp)
jmp 0x3095
movl $0x6, %eax
cmpl -0x10(%rbp), %eax
je 0x3054
movl $0xa, %eax
cmpl -0x10(%rbp), %eax
je 0x3054
movl $0xd, %eax
cmpl -0x10(%rbp), %eax
je 0x3054
movl $0xe, %eax
cmpl -0x10(%rbp), %eax
je 0x3054
movl $0xf, %eax
cmpl -0x10(%rbp), %eax
je 0x3054
movl $0x13, %eax
cmpl -0x10(%rbp), %eax
je 0x3054
movl $0x14, %eax
cmpl -0x10(%rbp), %eax
je 0x3054
movl $0x18, %eax
cmpl -0x10(%rbp), %eax
je 0x3054
movl $0x19, %eax
cmpl -0x10(%rbp), %eax
je 0x3054
movl $0x1b, %eax
cmpl -0x10(%rbp), %eax
je 0x3054
movl $0x1c, %eax
cmpl -0x10(%rbp), %eax
je 0x3054
movl $0x1d, %eax
cmpl -0x10(%rbp), %eax
jne 0x305f
movl -0x8(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x8(%rbp)
jmp 0x3093
movl $0x7, %eax
cmpl -0x10(%rbp), %eax
je 0x307d
movl $0x17, %eax
cmpl -0x10(%rbp), %eax
je 0x307d
movl $0x16, %eax
cmpl -0x10(%rbp), %eax
jne 0x3088
movl -0x8(%rbp), %eax
addl $0x5, %eax
movl %eax, -0x8(%rbp)
jmp 0x3091
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3093
jmp 0x3095
jmp 0x2f74
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: cons3
cell cons3(cell pcar, cell pcdr, int ptag) {
	cell	n;
	int	k;

	if (NIL == Freelist) {
		if (0 == (ptag & ~CONST_TAG))
			Tmp_car = pcar;
		if (!(ptag & VECTOR_TAG))
			Tmp_cdr = pcdr;
		k = gc();
		if (k < NNODES / 2) {
			/* memory low! */
		}
		Tmp_car = Tmp_cdr = NIL;
		if (NIL == Freelist)
			error("cons3: out of nodes", UNDEF);
	}
	n = Freelist;
	Freelist = cdr(Freelist);
	car(n) = pcar;
	cdr(n) = pcdr;
	tag(n) = ptag;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x1c784(%rip), %eax     # 0x20130
jne 0x3a21
movl -0xc(%rbp), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x39c6
movl -0x4(%rbp), %eax
movl %eax, 0x1c7a2(%rip)     # 0x20168
movl -0xc(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x39da
movl -0x8(%rbp), %eax
movl %eax, 0x1c792(%rip)     # 0x2016c
callq 0x3580
movl %eax, -0x14(%rbp)
cmpl $0x20000, -0x14(%rbp)   # imm = 0x20000
jge 0x39ed
jmp 0x39ed
movl $0xffffffff, 0x1c775(%rip) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x1c767(%rip) # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x1c724(%rip), %eax     # 0x20130
jne 0x3a1f
leaq 0x17a89(%rip), %rdi     # 0x1b49e
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x26c0
jmp 0x3a21
movl 0x1c709(%rip), %eax     # 0x20130
movl %eax, -0x10(%rbp)
movq 0x1c917(%rip), %rax     # 0x20348
movslq 0x1c6f8(%rip), %rcx     # 0x20130
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c6ef(%rip)     # 0x20130
movl -0x4(%rbp), %edx
movq 0x1c8f5(%rip), %rax     # 0x20340
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %edx
movq 0x1c8ec(%rip), %rax     # 0x20348
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
movb %al, %dl
movq 0x1c8e1(%rip), %rax     # 0x20350
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: unmark_vecs
void unmark_vecs(void) {
	int	p, k, link;

	p = 0;
	while (p < Freevec) {
		link = p;
		k = Vectors[p + RAW_VECSIZE];
		p += vecsize(k);
		Vectors[link] = NIL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x1c8cc(%rip), %eax     # 0x20360
jge 0x3ae4
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x1c8b5(%rip), %rax     # 0x20358
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
addq $0x4, %rcx
subq $0x1, %rcx
shrq $0x2, %rcx
addq $0x2, %rcx
movslq -0x4(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x4(%rbp)
movq 0x1c881(%rip), %rax     # 0x20358
movslq -0xc(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x3a8b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: gcv
int gcv(void) {
	int	v, k, to, from;
	char	buf[100];

	unmark_vecs();
	gc();		/* re-mark live vectors */
	to = from = 0;
	while (from < Freevec) {
		v = Vectors[from + RAW_VECSIZE];
		k = vecsize(v);
		if (Vectors[from + RAW_VECLINK] != NIL) {
			if (to != from) {
				memmove(&Vectors[to], &Vectors[from],
					k * sizeof(cell));
				cdr(Vectors[to + RAW_VECLINK]) =
					to + RAW_VECDATA;
			}
			to += k;
		}
		from += k;
	}
	k = Freevec - to;
	if (GC_verbose) {
		sprintf(buf, "GCV: %d cells reclaimed", k);
		prints(buf); nl();
		flush();
	}
	Freevec = to;
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0x3a80
callq 0x3580
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x1c844(%rip), %eax     # 0x20360
jge 0x3bd9
movq 0x1c82f(%rip), %rax     # 0x20358
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
addq $0x2, %rax
movl %eax, -0x8(%rbp)
movq 0x1c802(%rip), %rax     # 0x20358
movl -0x10(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x3bcb
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x3bc2
movq 0x1c7e4(%rip), %rdi     # 0x20358
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x1c7d2(%rip), %rsi     # 0x20358
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movslq -0x8(%rbp), %rdx
shlq $0x2, %rdx
callq 0x21b0
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq 0x1c79d(%rip), %rax     # 0x20348
movq 0x1c7a6(%rip), %rcx     # 0x20358
movl -0xc(%rbp), %esi
addl $0x0, %esi
movslq %esi, %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3b13
movl 0x1c781(%rip), %eax     # 0x20360
subl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, 0x1ca28(%rip)     # 0x20614
je 0x3c1d
leaq -0x80(%rbp), %rdi
movl -0x8(%rbp), %edx
leaq 0x178b6(%rip), %rsi     # 0x1b4b2
movb $0x0, %al
callq 0x21f0
leaq -0x80(%rbp), %rdi
callq 0x25a0
leaq 0x1866d(%rip), %rdi     # 0x1c280
callq 0x25a0
callq 0x2af0
movl -0xc(%rbp), %eax
movl %eax, 0x1c73a(%rip)     # 0x20360
movl -0x8(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: newvec
cell newvec(cell type, int size) {
	cell	n;
	int	v, wsize;

	wsize = vecsize(size);
	if (Freevec + wsize >= NVCELLS) {
		gcv();
		if (Freevec + wsize >= NVCELLS)
			error("newvec: out of vector space", UNDEF);
	}
	v = Freevec;
	Freevec += wsize;
	n = cons3(type, v + RAW_VECDATA, VECTOR_TAG);
	Vectors[v + RAW_VECLINK] = n;
	Vectors[v + RAW_VECSIZE] = size;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x8(%rbp), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
addq $0x2, %rax
movl %eax, -0x14(%rbp)
movl 0x1c6f5(%rip), %eax     # 0x20360
addl -0x14(%rbp), %eax
cmpl $0x40000, %eax          # imm = 0x40000
jl 0x3c9d
callq 0x3af0
movl 0x1c6e0(%rip), %eax     # 0x20360
addl -0x14(%rbp), %eax
cmpl $0x40000, %eax          # imm = 0x40000
jl 0x3c9b
leaq 0x17839(%rip), %rdi     # 0x1b4ca
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x26c0
jmp 0x3c9d
movl 0x1c6bd(%rip), %eax     # 0x20360
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl 0x1c6b1(%rip), %eax     # 0x20360
movl %eax, 0x1c6ab(%rip)     # 0x20360
movl -0x4(%rbp), %edi
movl -0x10(%rbp), %esi
addl $0x2, %esi
movl $0x8, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
movq 0x1c683(%rip), %rax     # 0x20358
movl -0x10(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %edx
movq 0x1c66d(%rip), %rax     # 0x20358
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: unprot
cell unprot(int k) {
	cell	n = NIL; /*LINT*/

	while (k) {
		if (NIL == Protected)
			error("unprot: stack underflow", UNDEF);
		n = car(Protected);
		Protected = cdr(Protected);
		k--;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x4(%rbp)
je 0x3d6c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x1c44d(%rip), %eax     # 0x20170
jne 0x3d36
leaq 0x177ba(%rip), %rdi     # 0x1b4e6
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x26c0
movq 0x1c603(%rip), %rax     # 0x20340
movslq 0x1c42c(%rip), %rcx     # 0x20170
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movq 0x1c5f7(%rip), %rax     # 0x20348
movslq 0x1c418(%rip), %rcx     # 0x20170
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c40f(%rip)     # 0x20170
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3d12
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: mkvec
cell mkvec(int k) {
	cell	n, *v;
	int	i;

	if (0 == k) return Nullvec;
	n = newvec(T_VECTOR, k * sizeof(cell));
	v = vector(n);
	for (i=0; i<k; i++) v[i] = NIL;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jne 0x3d9d
movl 0x1c3e4(%rip), %eax     # 0x2017c
movl %eax, -0x4(%rbp)
jmp 0x3e04
movslq -0x8(%rbp), %rax
shlq $0x2, %rax
movl %eax, %esi
movl $0xffffffed, %edi       # imm = 0xFFFFFFED
callq 0x3c40
movl %eax, -0xc(%rbp)
movq 0x1c59d(%rip), %rax     # 0x20358
movq 0x1c586(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x3dfe
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ddc
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: htsize
int htsize(int n) {
	if (n < 47) return 47;
	if (n < 97) return 97;
	if (n < 199) return 199;
	if (n < 499) return 499;
	if (n < 997) return 997;
	if (n < 9973) return 9973;
	if (n < 19997) return 19997;
	return 39989;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x2f, -0x8(%rbp)
jge 0x3e26
movl $0x2f, -0x4(%rbp)
jmp 0x3e96
cmpl $0x61, -0x8(%rbp)
jge 0x3e35
movl $0x61, -0x4(%rbp)
jmp 0x3e96
cmpl $0xc7, -0x8(%rbp)
jge 0x3e47
movl $0xc7, -0x4(%rbp)
jmp 0x3e96
cmpl $0x1f3, -0x8(%rbp)      # imm = 0x1F3
jge 0x3e59
movl $0x1f3, -0x4(%rbp)      # imm = 0x1F3
jmp 0x3e96
cmpl $0x3e5, -0x8(%rbp)      # imm = 0x3E5
jge 0x3e6b
movl $0x3e5, -0x4(%rbp)      # imm = 0x3E5
jmp 0x3e96
cmpl $0x26f5, -0x8(%rbp)     # imm = 0x26F5
jge 0x3e7d
movl $0x26f5, -0x4(%rbp)     # imm = 0x26F5
jmp 0x3e96
cmpl $0x4e1d, -0x8(%rbp)     # imm = 0x4E1D
jge 0x3e8f
movl $0x4e1d, -0x4(%rbp)     # imm = 0x4E1D
jmp 0x3e96
movl $0x9c35, -0x4(%rbp)     # imm = 0x9C35
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: mkht
cell mkht(int k) {
	cell	n;

	n = mkfix(0); /* mutable, can't use Zero */
	protect(n);
	n = cons(n, mkvec(htsize(k)));
	unprot(1);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
xorl %edi, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl 0x1c297(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x1c28a(%rip)     # 0x20170
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
callq 0x3e10
movl %eax, %edi
callq 0x3d80
movl -0xc(%rbp), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x8(%rbp)
movl $0x1, %edi
callq 0x3d00
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: obhash
uint obhash(cell x, uint k) {
	if (specialp(x))
		return abs(x) % k;
	if (symbolp(x))
		return hash(symname(x), k);
	if (fixp(x))
		return abs(fixval(x)) % k;
	if (charp(x))
		return charval(x) % k;
	if (stringp(x))
		return hash(string(x), k);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x3f9b
movl -0x8(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, -0x4(%rbp)
jmp 0x4111
cmpl $0x0, -0x8(%rbp)
jl 0x3ffa
movq 0x1c3a8(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x3ffa
movq 0x1c381(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
cmpl (%rcx,%rdx,4), %eax
jne 0x3ffa
movq 0x1c384(%rip), %rdi     # 0x20358
movq 0x1c36d(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3f20
movl %eax, -0x4(%rbp)
jmp 0x4111
cmpl $0x0, -0x8(%rbp)
jl 0x4059
movq 0x1c349(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4059
movq 0x1c322(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
jne 0x4059
movq 0x1c30d(%rip), %rax     # 0x20340
movq 0x1c30e(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, -0x4(%rbp)
jmp 0x4111
cmpl $0x0, -0x8(%rbp)
jl 0x40ae
movq 0x1c2ea(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x40ae
movq 0x1c2c3(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff4, %eax       # imm = 0xFFFFFFF4
cmpl (%rcx,%rdx,4), %eax
jne 0x40ae
movq 0x1c2ae(%rip), %rax     # 0x20340
movq 0x1c2af(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, -0x4(%rbp)
jmp 0x4111
cmpl $0x0, -0x8(%rbp)
jl 0x410a
movq 0x1c295(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x410a
movq 0x1c26e(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xffffffef, %eax       # imm = 0xFFFFFFEF
cmpl (%rcx,%rdx,4), %eax
jne 0x410a
movq 0x1c271(%rip), %rdi     # 0x20358
movq 0x1c25a(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3f20
movl %eax, -0x4(%rbp)
jmp 0x4111
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: htlookup
int htlookup(cell d, cell k) {
	cell	x;
	int	h;

	h = obhash(k, htlen(d));
	x = htslots(d)[h];
	while (x != NIL) {
		if (match(caar(x), k)) return car(x);
		x = cdr(x);
	}
	return UNDEF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
movq 0x1bc10(%rip), %rax     # 0x20358
movq 0x1bbf9(%rip), %rcx     # 0x20348
movq 0x1bbf2(%rip), %rdx     # 0x20348
movslq -0x8(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
addq $0x2, %rax
subq $0x2, %rax
movl %eax, %esi
callq 0x3f70
movl %eax, -0x14(%rbp)
movq 0x1bbc8(%rip), %rax     # 0x20358
movq 0x1bbb1(%rip), %rcx     # 0x20348
movq 0x1bbaa(%rip), %rdx     # 0x20348
movslq -0x8(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
je 0x480d
movq 0x1bb78(%rip), %rax     # 0x20340
movq 0x1bb71(%rip), %rcx     # 0x20340
movslq -0x10(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl -0xc(%rbp), %esi
callq 0x4120
cmpl $0x0, %eax
je 0x47fa
movq 0x1bb52(%rip), %rax     # 0x20340
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x4814
movq 0x1bb47(%rip), %rax     # 0x20348
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
jmp 0x47bb
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)