LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./imgp.h
// Function: node_free
void node_free()
{
	oct_node p;
	while (oct_pool) {
		p = oct_pool->parent;
		free(oct_pool);
		oct_pool = p;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x32b20(%rip)     # 0x3ac10
je 0x811a
movq 0x32b17(%rip), %rax     # 0x3ac10
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
movq 0x32b08(%rip), %rdi     # 0x3ac10
callq 0x1030
movq -0x8(%rbp), %rax
movq %rax, 0x32af8(%rip)     # 0x3ac10
jmp 0x80e8
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./imgp.h
// Function: node_insert
oct_node node_insert(oct_node root, unsigned char *pix)
{
	unsigned char i, bit, depth = 0;
	for (bit = 1 << 7; ++depth < OCT_DEPTH; bit >>= 1) {
		i = !!(pix[1] & bit) * 4 + !!(pix[0] & bit) * 2 + !!(pix[2] & bit);
		if (!root->kids[i]) {
			root->kids[i] = node_new(i, depth, root);
		}

		root = root->kids[i];
	}

	root->r += pix[0];
	root->g += pix[1];
	root->b += pix[2];
	root->count++;
	return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x13(%rbp)
movb $-0x80, -0x12(%rbp)
movb -0x13(%rbp), %al
addb $0x1, %al
movb %al, -0x13(%rbp)
movzbl %al, %eax
cmpl $0x8, %eax
jge 0x8208
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movzbl -0x12(%rbp), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
shll $0x2, %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl -0x12(%rbp), %edx
andl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
movzbl -0x12(%rbp), %edx
andl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x11(%rbp), %ecx
cmpq $0x0, 0x20(%rax,%rcx,8)
jne 0x81e9
movb -0x11(%rbp), %cl
movb -0x13(%rbp), %al
movq -0x8(%rbp), %rdx
movzbl %cl, %edi
movzbl %al, %esi
callq 0x8020
movq %rax, %rdx
movq -0x8(%rbp), %rax
movzbl -0x11(%rbp), %ecx
movq %rdx, 0x20(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movzbl -0x11(%rbp), %ecx
movq 0x20(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movzbl -0x12(%rbp), %eax
sarl %eax
movb %al, -0x12(%rbp)
jmp 0x8138
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./imgp.h
// Function: node_fold
oct_node node_fold(oct_node p)
{
	if (p->n_kids) abort();
	oct_node q = p->parent;
	q->count += p->count;

	q->r += p->r;
	q->g += p->g;
	q->b += p->b;
	q->n_kids --;
	q->kids[p->kid_idx] = 0;
	return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x68(%rax)
je 0x827b
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movb 0x68(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x68(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl 0x69(%rcx), %ecx
movq $0x0, 0x20(%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./imgp.h
// Function: color_replace
void color_replace(oct_node root, unsigned char *pix)
{
	unsigned char i, bit;

	for (bit = 1 << 7; bit; bit >>= 1) {
		i = !!(pix[1] & bit) * 4 + !!(pix[0] & bit) * 2 + !!(pix[2] & bit);
		if (!root->kids[i]) break;
		root = root->kids[i];
	}

	pix[0] = root->r;
	pix[1] = root->g;
	pix[2] = root->b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $-0x80, -0x12(%rbp)
cmpb $0x0, -0x12(%rbp)
je 0x83b3
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movzbl -0x12(%rbp), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
shll $0x2, %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl -0x12(%rbp), %edx
andl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
movzbl -0x12(%rbp), %edx
andl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x11(%rbp), %ecx
cmpq $0x0, 0x20(%rax,%rcx,8)
jne 0x8394
jmp 0x83b3
movq -0x8(%rbp), %rax
movzbl -0x11(%rbp), %ecx
movq 0x20(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movzbl -0x12(%rbp), %eax
sarl %eax
movb %al, -0x12(%rbp)
jmp 0x8310
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./imgp.h
// Function: imgp_color_quant
void imgp_color_quant(unsigned char *im, int w, int h, int n_colors)
{
	int i;
	unsigned char *pix = im;
	node_heap heap = { 0, 0, 0 };

	oct_node root = node_new(0, 0, 0);
	for (i=0; i < w * h; i++, pix += 3) {
		heap_add(&heap, node_insert(root, pix));
	}

	while (heap.n > n_colors + 1) {
		heap_add(&heap, node_fold(pop_heap(&heap)));
	}

	/*for (i=1; i < heap.n; i++) {
		oct_node got = heap.buf[i];
		double c = got->count;
		got->r = got->r / c + .5;
		got->g = got->g / c + .5;
		got->b = got->b / c + .5;
		printf("%2d | %3lu %3lu %3lu (%d pixels)\n",
		       i, got->r, got->g, got->b, got->count);
	}*/

	for (i=0, pix = im; i < w * h; i++, pix += 3) {
		color_replace(root, pix);
	}

	node_free();
	free(heap.buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10f0
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movl %esi, %edi
callq 0x8020
movq %rax, -0x38(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0xc(%rbp), %ecx
imull -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x8473
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8120
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x7e70
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
jmp 0x8435
jmp 0x8475
movl -0x2c(%rbp), %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0x84a1
leaq -0x30(%rbp), %rdi
callq 0x7f70
movq %rax, %rdi
callq 0x8260
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x7e70
jmp 0x8475
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl -0xc(%rbp), %ecx
imull -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x84e2
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8300
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
jmp 0x84b0
callq 0x80e0
movq -0x28(%rbp), %rdi
callq 0x1030
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./imgp.h
// Function: rndunit_24to15
uint8_t rndunit_24to15(uint8_t u, int dither)
{
	uint8_t unit = (u & 0b11111000)>>3;
	uint8_t weight = (u & 0b00000111);
	if (dither && (weight - (rand() % 7) >=0) && (unit < 31)) {
		unit++;
	}
	return unit<<3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movzbl -0x1(%rbp), %eax
andl $0xf8, %eax
sarl $0x3, %eax
movb %al, -0x9(%rbp)
movzbl -0x1(%rbp), %eax
andl $0x7, %eax
movb %al, -0xa(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x855f
movzbl -0xa(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0x1250
movl $0x7, %ecx
cltd
idivl %ecx
movl -0x10(%rbp), %eax
subl %edx, %eax
cmpl $0x0, %eax
jl 0x855f
movzbl -0x9(%rbp), %eax
cmpl $0x1f, %eax
jge 0x855f
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
shll $0x3, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: path_new
path_t *path_new(void) {
  path_t *p = NULL;
  privpath_t *priv = NULL;
  SAFE_CALLOC(p, 1, path_t);
  memset(p, 0, sizeof(path_t));
  SAFE_CALLOC(priv, 1, privpath_t);
  memset(priv, 0, sizeof(privpath_t));
  p->priv = priv;
  return p;
 calloc_error:
  free(p);
  free(priv);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, %edi
movl $0x40, %esi
callq 0x1120
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8623
jmp 0x8674
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x10f0
movl $0x1, %edi
movl $0xc0, %esi
callq 0x1120
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x864e
jmp 0x8674
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0xc0, %edx
callq 0x10f0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x868e
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: path_free
void path_free(path_t *p) {
  if (p) {
    if (p->priv) {
      free(p->priv->pt);
      free(p->priv->lon);
      free(p->priv->sums);
      free(p->priv->po);
      privcurve_free_members(&p->priv->curve);
      privcurve_free_members(&p->priv->ocurve);
    }
    free(p->priv);
    /* do not free p->fcurve ! */
  }
  free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8731
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x8724
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x30(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x38, %rdi
callq 0x8740
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x78, %rdi
callq 0x8740
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: privcurve_free_members
static void privcurve_free_members(privcurve_t *curve) {
  free(curve->tag);
  free(curve->c);
  free(curve->vertex);
  free(curve->alpha);
  free(curve->alpha0);
  free(curve->beta);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: privcurve_init
int privcurve_init(privcurve_t *curve, int n) {
  memset(curve, 0, sizeof(privcurve_t));
  curve->n = n;
  SAFE_CALLOC(curve->tag, n, int);
  SAFE_CALLOC(curve->c, n, dpoint3_t);
  SAFE_CALLOC(curve->vertex, n, dpoint_t);
  SAFE_CALLOC(curve->alpha, n, double);
  SAFE_CALLOC(curve->alpha0, n, double);
  SAFE_CALLOC(curve->beta, n, double);
  return 0;
 calloc_error:
  free(curve->tag);
  free(curve->c);
  free(curve->vertex);
  free(curve->alpha);
  free(curve->alpha0);
  free(curve->beta);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x10f0
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movslq -0x14(%rbp), %rdi
movl $0x4, %esi
callq 0x1120
movq -0x10(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x8859
jmp 0x88fb
movslq -0x14(%rbp), %rdi
movl $0x30, %esi
callq 0x1120
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x887a
jmp 0x88fb
movslq -0x14(%rbp), %rdi
movl $0x10, %esi
callq 0x1120
movq -0x10(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x8898
jmp 0x88fb
movslq -0x14(%rbp), %rdi
movl $0x8, %esi
callq 0x1120
movq -0x10(%rbp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
jne 0x88b6
jmp 0x88fb
movslq -0x14(%rbp), %rdi
movl $0x8, %esi
callq 0x1120
movq -0x10(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0x88d4
jmp 0x88fb
movslq -0x14(%rbp), %rdi
movl $0x8, %esi
callq 0x1120
movq -0x10(%rbp), %rcx
movq %rax, 0x38(%rcx)
cmpq $0x0, %rax
jne 0x88f2
jmp 0x88fb
movl $0x0, -0x4(%rbp)
jmp 0x8950
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: reverse
static void reverse(privcurve_t *curve) {
  int m = curve->n;
  int i, j;
  dpoint_t tmp;
  for (i=0, j=m-1; i<j; i++, j--) {
    tmp = curve->vertex[i];
    curve->vertex[i] = curve->vertex[j];
    curve->vertex[j] = tmp;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xab4c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xaab1
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: progress_update
static inline void progress_update(double d, progress_t *prog) {
  double d_scaled;
  if (prog != NULL && prog->callback != NULL) {
    d_scaled = prog->min * (1-d) + prog->max * d;
    if (d == 1.0 || d_scaled >= prog->d_prev + prog->epsilon) {
      prog->callback(prog->min * (1-d) + prog->max * d, prog->data);
      prog->d_prev = d_scaled;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbeac
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xbeac
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x2620d(%rip), %xmm2    # 0x32018
subsd -0x8(%rbp), %xmm2
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm1
mulsd -0x8(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x261e0(%rip), %xmm1    # 0x32018
ucomisd %xmm1, %xmm0
jne 0xbe42
jp 0xbe42
jmp 0xbe5f
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm1
movq -0x10(%rbp), %rax
addsd 0x20(%rax), %xmm1
ucomisd %xmm1, %xmm0
jb 0xbeaa
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd 0x261a1(%rip), %xmm2    # 0x32018
subsd -0x8(%rbp), %xmm2
movq -0x10(%rbp), %rcx
movsd 0x18(%rcx), %xmm1
mulsd -0x8(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x30(%rax)
jmp 0xbeac
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: bm_dup
static inline potrace_bitmap_t *bm_dup(const potrace_bitmap_t *bm) {
  potrace_bitmap_t *bm1 = bm_new(bm->w, bm->h);
  int y;
  
  if (!bm1) {
    return NULL;
  }
  for (y=0; y < bm->h; y++) {
    memcpy(bm_scanline(bm1, y), bm_scanline(bm, y), (size_t)bm1->dy * (size_t)BM_WORDSIZE);
  }
  return bm1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xdc10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc183
movq $0x0, -0x8(%rbp)
jmp 0xc1f8
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xc1f0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq 0x8(%rcx), %rcx
imulq %rcx, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
imulq %rcx, %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rax
movslq 0x8(%rax), %rdx
shlq $0x3, %rdx
callq 0x1180
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc18a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: bm_clearexcess
static void bm_clearexcess(potrace_bitmap_t *bm) {
  potrace_word mask;
  int y;
  if (bm->w % BM_WORDBITS != 0) {
    mask = BM_ALLBITS << (BM_WORDBITS - (bm->w % BM_WORDBITS));
    for (y=0; y<bm->h; y++) {
      *bm_index(bm, bm->w, y) &= mask;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xc2c4
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl $0x40, %eax
subl %edx, %eax
movl %eax, %eax
movl %eax, %ecx
movq $-0x1, %rax
shlq %cl, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xc2c2
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq -0x8(%rbp), %rdx
movslq 0x8(%rdx), %rdx
imulq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rdx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc25d
jmp 0xc2c4
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: findnext
static int findnext(potrace_bitmap_t *bm, int *xp, int *yp) {
  int x;
  int y;
  int x0;
  x0 = (*xp) & ~(BM_WORDBITS-1);
  for (y=*yp; y>=0; y--) {
    for (x=x0; x<bm->w && x>=0; x+=(unsigned)BM_WORDBITS) {
      if (*bm_index(bm, x, y)) {
	while (!BM_GET(bm, x, y)) {
	  x++;
	}
	/* found */
	*xp = x;
	*yp = y;
	return 0;
      }
    }
    x0 = 0;
  }
  /* not found */
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $-0x40, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0xc463
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x2d(%rbp)
jge 0xc31f
cmpl $0x0, -0x24(%rbp)
setge %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0xc32b
jmp 0xc44e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq 0x8(%rdx), %rdx
imulq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xc43e
jmp 0xc36f
cmpl $0x0, -0x24(%rbp)
jl 0xc3fd
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xc3fd
cmpl $0x0, -0x28(%rbp)
jl 0xc3fd
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xc3fd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq 0x8(%rdx), %rdx
imulq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0x24(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x24(%rbp), %ecx
andl $0x3f, %ecx
movl %ecx, %ecx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
jmp 0xc404
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0xc404
movl -0x3c(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc415
jmp 0xc423
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc36f
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xc46a
jmp 0xc440
movl -0x24(%rbp), %eax
addl $0x40, %eax
movl %eax, -0x24(%rbp)
jmp 0xc305
movl $0x0, -0x2c(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xc2f5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: xor_path
static void xor_path(potrace_bitmap_t *bm, path_t *p) {
  int xa, x, y, k, y1;
  if (p->priv->len <= 0) {  /* a path of length 0 is silly, but legal */
    return;
  }
  y1 = p->priv->pt[p->priv->len-1].y;
  xa = p->priv->pt[0].x & -BM_WORDBITS;
  for (k=0; k<p->priv->len; k++) {
    x = p->priv->pt[k].x;
    y = p->priv->pt[k].y;
    if (y != y1) {
      /* efficiently invert the rectangle [x,xa] x [y,y1] */
      xor_to_ref(bm, x, min(y,y1), xa);
      y1 = y;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpl $0x0, (%rax)
jg 0xca62
jmp 0xcb4b
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $-0x40, %rax
movl %eax, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
cmpl (%rcx), %eax
jge 0xcb4b
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0xcb3b
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xcb1d
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xcb23
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %esi
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x2f230
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xcb3d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xcaa9
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: potrace_param_default
potrace_param_t *potrace_param_default(void) {
  potrace_param_t *p;
  p = (potrace_param_t *) malloc(sizeof(potrace_param_t));
  if (!p) {
    return NULL;
  }
  memcpy(p, &param_default, sizeof(potrace_param_t));
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x48, %edi
callq 0x1190
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd087
movq $0x0, -0x8(%rbp)
jmp 0xd0a4
movq -0x10(%rbp), %rdi
leaq 0x232f6(%rip), %rsi     # 0x30388
movl $0x48, %edx
callq 0x1180
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: potrace_trace
potrace_state_t *potrace_trace(const potrace_param_t *param, const potrace_bitmap_t *bm) {
  int r;
  path_t *plist = NULL;
  potrace_state_t *st;
  progress_t prog;
  progress_t subprog;
  
  /* prepare private progress bar state */
  prog.callback = param->progress.callback;
  prog.data = param->progress.data;
  prog.min = param->progress.min;
  prog.max = param->progress.max;
  prog.epsilon = param->progress.epsilon;
  prog.d_prev = param->progress.min;
  /* allocate state object */
  st = (potrace_state_t *)malloc(sizeof(potrace_state_t));
  if (!st) {
    return NULL;
  }
  progress_subrange_start(0.0, 0.1, &prog, &subprog);
  /* process the image */
  r = bm_to_pathlist(bm, &plist, param, &subprog);
  if (r) {
    free(st);
    return NULL;
  }
  st->status = POTRACE_STATUS_OK;
  st->plist = plist;
  st->priv = NULL;  /* private state currently unused */
  progress_subrange_end(&prog, &subprog);
  progress_subrange_start(0.1, 1.0, &prog, &subprog);
  /* partial success. */
  r = process_path(plist, param, &subprog);
  if (r) {
    st->status = POTRACE_STATUS_INCOMPLETE;
  }
  progress_subrange_end(&prog, &subprog);
  return st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movsd 0x40(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x18, %edi
callq 0x1190
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xd13d
movq $0x0, -0x8(%rbp)
jmp 0xd220
xorps %xmm0, %xmm0
movsd 0x24f18(%rip), %xmm1    # 0x32060
leaq -0x68(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xd230
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x28(%rbp), %rsi
leaq -0xa0(%rbp), %rcx
callq 0xbec0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xd18f
movq -0x30(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0xd220
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
leaq -0x68(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xd360
movsd 0x24e97(%rip), %xmm0    # 0x32060
movsd 0x24e47(%rip), %xmm1    # 0x32018
leaq -0x68(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xd230
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x89a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xd208
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
leaq -0x68(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xd360
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: progress_subrange_start
static inline void progress_subrange_start(double a, double b, const progress_t *prog, progress_t *sub) {
  double min, max;
  if (prog == NULL || prog->callback == NULL) {
    sub->callback = NULL;
    return;
  }
  min = prog->min * (1-a) + prog->max * a;
  max = prog->min * (1-b) + prog->max * b;
  if (max - min < prog->epsilon) {
    sub->callback = NULL;    /* no further progress info in subrange */
    sub->b = b;
    return;
  }
  sub->callback = prog->callback;
  sub->data = prog->data;
  sub->epsilon = prog->epsilon;
  sub->min = min;
  sub->max = max;
  sub->d_prev = prog->d_prev;
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd257
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd267
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0xd35b
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x24da0(%rip), %xmm2    # 0x32018
subsd -0x8(%rbp), %xmm2
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm1
mulsd -0x8(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x24d6f(%rip), %xmm2    # 0x32018
subsd -0x10(%rbp), %xmm2
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm1
mulsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm1
subsd -0x28(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd2fd
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x28(%rax)
jmp 0xd35b
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rax
movsd 0x30(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x30(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: progress_subrange_end
static inline void progress_subrange_end(progress_t *prog, progress_t *sub) {
  if (prog != NULL && prog->callback != NULL) {
    if (sub->callback == NULL) {
      progress_update(sub->b, prog);
    } else {
      prog->d_prev = sub->d_prev;
    }
  }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd3b3
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd3b3
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd39f
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm0
movq -0x8(%rbp), %rdi
callq 0xbdd0
jmp 0xd3b1
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
jmp 0xd3b3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: bm_new
static inline potrace_bitmap_t *bm_new(int w, int h) {
  potrace_bitmap_t *bm;
  int dy = w == 0 ? 0 : (w - 1) / BM_WORDBITS + 1;
  ptrdiff_t size;
  size = getsize(dy, h);
  if (size < 0) {
    errno = ENOMEM;
    return NULL;
  }
  if (size == 0) {
    size = BM_WORDSIZE; /* make sure calloc() doesn't return NULL */
  } 
  bm = (potrace_bitmap_t *) malloc(sizeof(potrace_bitmap_t));
  if (!bm) {
    return NULL;
  }
  bm->w = w;
  bm->h = h;
  bm->dy = dy;
  bm->map = (potrace_word *) calloc(1, size);
  if (!bm->map) {
    free(bm);
    return NULL;
  }
  return bm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xdc2b
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0xdc3f
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl $0x40, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x2f610
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0xdc73
callq 0x1050
movl $0xc, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xdcfd
cmpq $0x0, -0x28(%rbp)
jne 0xdc82
movq $0x8, -0x28(%rbp)
movl $0x18, %edi
callq 0x1190
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdca1
movq $0x0, -0x8(%rbp)
jmp 0xdcfd
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rsi
movl $0x1, %edi
callq 0x1120
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xdcf5
movq -0x18(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0xdcfd
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: cyclic
static inline int cyclic(int a, int b, int c) {
  if (a<=c) {
    return (a<=b && b<c);
  } else {
    return (a<=b || b<c);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x2caeb
movl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x11(%rbp)
jg 0x2cade
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x2cb0f
movl -0x8(%rbp), %ecx
movb $0x1, %al
cmpl -0xc(%rbp), %ecx
movb %al, -0x12(%rbp)
jle 0x2cb04
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
setl %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: quadform
static inline double quadform(quadform_t Q, dpoint_t w) {
  double v[3];
  int i, j;
  double sum;
  v[0] = w.x;
  v[1] = w.y;
  v[2] = 1;
  sum = 0.0;
  for (i=0; i<3; i++) {
    for (j=0; j<3; j++) {
      sum += v[i] * Q[i][j] * v[j];
    }
  }
  return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x49fa(%rip), %xmm0     # 0x32018
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jge 0x2d69b
movl $0x0, -0x38(%rbp)
cmpl $0x3, -0x38(%rbp)
jge 0x2d68e
movslq -0x34(%rbp), %rax
movsd -0x30(%rbp,%rax,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x38(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movslq -0x38(%rbp), %rax
movsd -0x30(%rbp,%rax,8), %xmm2
movsd -0x40(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2d63f
jmp 0x2d690
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2d632
movsd -0x40(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: interval
static inline dpoint_t interval(double lambda, dpoint_t a, dpoint_t b) {
  dpoint_t res;
  res.x = a.x + lambda * (b.x - a.x);
  res.y = a.y + lambda * (b.y - a.y);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: dpara
static inline double dpara(dpoint_t p0, dpoint_t p1, dpoint_t p2) {
  double x1, y1, x2, y2;
  x1 = p1.x-p0.x;
  y1 = p1.y-p0.y;
  x2 = p2.x-p0.x;
  y2 = p2.y-p0.y;
  return x1*y2 - x2*y1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x18(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
movsd -0x48(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: dorth_infty
static inline point_t dorth_infty(dpoint_t p0, dpoint_t p2) {
  point_t r;
  
  r.y = sign(p2.x-p0.x);
  r.x = -sign(p2.y-p0.y);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2d885
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2d8a3
movsd -0x30(%rbp), %xmm1
subsd -0x20(%rbp), %xmm1
xorps %xmm0, %xmm0
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
ucomisd %xmm1, %xmm0
cmoval %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cltq
movq %rax, -0x8(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2d8c9
movl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2d8e7
movsd -0x28(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
xorps %xmm0, %xmm0
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
ucomisd %xmm1, %xmm0
cmoval %ecx, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
negl %eax
cltq
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: cprod
static inline double cprod(dpoint_t p0, dpoint_t p1, dpoint_t p2, dpoint_t p3) {
  double x1, y1, x2, y2;
  x1 = p1.x - p0.x;
  y1 = p1.y - p0.y;
  x2 = p3.x - p2.x;
  y2 = p3.y - p2.y;
  return x1*y2 - x2*y1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x18(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x28(%rbp)
movsd %xmm6, -0x40(%rbp)
movsd %xmm7, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x40(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x48(%rbp), %xmm0
movsd -0x60(%rbp), %xmm2
movsd -0x58(%rbp), %xmm1
mulsd -0x50(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: iprod1
static inline double iprod1(dpoint_t p0, dpoint_t p1, dpoint_t p2, dpoint_t p3) {
  double x1, y1, x2, y2;
  x1 = p1.x - p0.x;
  y1 = p1.y - p0.y;
  x2 = p3.x - p2.x;
  y2 = p3.y - p2.y;
  return x1*x2 + y1*y2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x18(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x28(%rbp)
movsd %xmm6, -0x40(%rbp)
movsd %xmm7, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x40(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x48(%rbp), %xmm0
movsd -0x58(%rbp), %xmm2
movsd -0x50(%rbp), %xmm1
mulsd -0x60(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: bezier
static inline dpoint_t bezier(double t, dpoint_t p0, dpoint_t p1, dpoint_t p2, dpoint_t p3) {
  double s = 1-t;
  dpoint_t res;
  /* Note: a good optimizing compiler (such as gcc-3) reduces the
     following to 16 multiplications, using common subexpression
     elimination. */
  res.x = s*s*s*p0.x + 3*(s*s*t)*p1.x + 3*(t*t*s)*p2.x + t*t*t*p3.x;
  res.y = s*s*s*p0.y + 3*(s*s*t)*p1.y + 3*(t*t*s)*p2.y + t*t*t*p3.y;
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm5, -0x40(%rbp)
movsd %xmm6, -0x38(%rbp)
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm1
movsd 0x3400(%rip), %xmm0     # 0x32018
subsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm5
movaps %xmm5, %xmm0
mulsd %xmm0, %xmm0
movaps %xmm0, %xmm3
mulsd %xmm5, %xmm3
movsd -0x20(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
mulsd %xmm2, %xmm0
movsd 0x3456(%rip), %xmm4     # 0x320a0
mulsd %xmm4, %xmm0
movsd -0x30(%rbp), %xmm6
mulsd %xmm6, %xmm0
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movaps %xmm2, %xmm0
mulsd %xmm0, %xmm0
movaps %xmm0, %xmm1
mulsd %xmm5, %xmm1
mulsd %xmm4, %xmm1
movsd -0x40(%rbp), %xmm5
mulsd %xmm5, %xmm1
addsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x50(%rbp), %xmm5
movaps %xmm5, %xmm0
mulsd %xmm0, %xmm0
movaps %xmm0, %xmm3
mulsd %xmm5, %xmm3
movsd -0x18(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm4, %xmm0
movsd -0x28(%rbp), %xmm6
mulsd %xmm6, %xmm0
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movaps %xmm2, %xmm0
mulsd %xmm0, %xmm0
movaps %xmm0, %xmm1
mulsd %xmm5, %xmm1
mulsd %xmm4, %xmm1
movsd -0x38(%rbp), %xmm4
mulsd %xmm4, %xmm1
addsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
movsd 0x8(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: iprod
static inline double iprod(dpoint_t p0, dpoint_t p1, dpoint_t p2) {
  double x1, y1, x2, y2;
  x1 = p1.x - p0.x;
  y1 = p1.y - p0.y;
  x2 = p2.x - p0.x;
  y2 = p2.y - p0.y;
  return x1*x2 + y1*y2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x18(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
mulsd -0x50(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yui0[P]img2vec/./potracelib.h
// Function: detrand
static inline int detrand(int x, int y) {
  unsigned int z;
  static const unsigned char t[256] = { 
    /* non-linear sequence: constant term of inverse in GF(8), 
       mod x^8+x^4+x^3+x+1 */
    0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 
    0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 
    0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 
    1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 
    0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 
    0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 
    0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 
    0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 
    1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 
    0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 
    1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 
  };
  /* 0x04b3e375 and 0x05a8ef93 are chosen to contain every possible
     5-bit sequence */
  z = ((0x04b3e375 * x) ^ y) * 0x05a8ef93;
  z = t[z & 0xff] ^ t[(z>>8) & 0xff] ^ t[(z>>16) & 0xff] ^ t[(z>>24) & 0xff];
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
imull $0x4b3e375, -0x4(%rbp), %eax # imm = 0x4B3E375
xorl -0x8(%rbp), %eax
imull $0x5a8ef93, %eax, %eax  # imm = 0x5A8EF93
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x3130(%rip), %rax      # 0x31ef0
movzbl (%rax,%rcx), %eax
movl -0xc(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x3115(%rip), %rcx      # 0x31ef0
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movl -0xc(%rbp), %ecx
shrl $0x10, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x30f8(%rip), %rcx      # 0x31ef0
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movl -0xc(%rbp), %ecx
shrl $0x18, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x30db(%rip), %rcx      # 0x31ef0
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)