LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ryuichiueda[P]glueutils/src/juz.c
// Function: main
int main(int argc, char * argv[])
{
	if(argc < 3){
		usage();
		exit(1);
	}

	long rep = strtol(argv[1], NULL, 10);
	if(errno != 0){
		printf("Error: %s\n", strerror(errno));
		exit(1);
	}

	for(int i=0;i<rep;i++){
		int pips[2];
		if(pipe(pips) < 0){
			fputs("Error: pipe open error", stderr);
			exit(1);
		}

		int pid = fork();
		if(pid == 0){//child proc
			if(i < rep-1){
				try_close(pips[0]);
				dup_and_close(pips[1], 1);
			}else{
				try_close(pips[1]);
			}
			return -execvp(argv[2], &argv[2]);
		}

		//parent proc
		try_close(pips[1]);
		dup_and_close(pips[0], 0);
	}

	int wstatus;
	int wpid;
	int lasterror = 0;
	while((wpid = waitpid(-1, &wstatus, 0)) > 0){
		if(WIFEXITED(wstatus) && WEXITSTATUS(wstatus)){
			lasterror = WEXITSTATUS(wstatus);
		}
	}
	exit(lasterror);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x2, %edi
jle 0x13f9
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
movl $0xa, %edx
callq 0x1090
movq %rax, %r14
callq 0x1030
movl (%rax), %edi
testl %edi, %edi
jne 0x13fe
testq %r14, %r14
setg %r13b
jle 0x13dc
leaq -0x1(%r14), %rax
movq %rax, 0x10(%rsp)
addq $0x10, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
leaq 0x8(%rsp), %rdi
callq 0x1080
testl %eax, %eax
js 0x13f4
callq 0x10e0
movl %eax, %ebp
testl %eax, %eax
je 0x1392
movl 0xc(%rsp), %edi
callq 0x127c
movl 0x8(%rsp), %edi
xorl %esi, %esi
callq 0x12b0
jmp 0x13cc
cmpq %r15, 0x10(%rsp)
jle 0x13b2
movl 0x8(%rsp), %edi
callq 0x127c
movl 0xc(%rsp), %edi
movl $0x1, %esi
callq 0x12b0
jmp 0x13bb
movl 0xc(%rsp), %edi
callq 0x127c
movq (%rbx), %rdi
movq %rbx, %rsi
callq 0x10b0
movl %eax, %r12d
negl %r12d
testl %ebp, %ebp
je 0x13dc
incq %r15
cmpq %r15, %r14
setg %r13b
jne 0x135f
testb $0x1, %r13b
je 0x141e
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1154
callq 0x1173
callq 0x10d0
leaq 0xcc0(%rip), %rdi       # 0x20ca
movq %rax, %rsi
xorl %eax, %eax
callq 0x1050
movl $0x1, %edi
callq 0x10c0
leaq 0x4(%rsp), %rsi
xorl %ebx, %ebx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x10a0
testl %eax, %eax
jle 0x1460
xorl %ebx, %ebx
leaq 0x4(%rsp), %r14
movl 0x4(%rsp), %eax
movzbl %ah, %ecx
testl %ecx, %ecx
cmovel %ebx, %ecx
testb $0x7f, %al
cmovel %ecx, %ebx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
xorl %edx, %edx
callq 0x10a0
testl %eax, %eax
jg 0x143c
movl %ebx, %edi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/mpc/mpc.c
// Function: mpcf_freefold
mpc_val_t *mpcf_freefold(int n, mpc_val_t **xs) {
  int i;
  for (i = 0; i < n; i++) {
    free(xs[i]);
  }
  return NULL;
}

// Assembly:
testl %edi, %edi
jle 0x7239
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2280
incq %r15
cmpq %r15, %r14
jne 0x7223
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/mpc/mpc.c
// Function: mpc_nodecount_unretained
static int mpc_nodecount_unretained(mpc_parser_t* p, int force) {

  int i, total;

  if (p->retained && !force) { return 0; }

  if (p->type == MPC_TYPE_EXPECT) { return 1 + mpc_nodecount_unretained(p->data.expect.x, 0); }

  if (p->type == MPC_TYPE_APPLY)    { return 1 + mpc_nodecount_unretained(p->data.apply.x, 0); }
  if (p->type == MPC_TYPE_APPLY_TO) { return 1 + mpc_nodecount_unretained(p->data.apply_to.x, 0); }
  if (p->type == MPC_TYPE_PREDICT)  { return 1 + mpc_nodecount_unretained(p->data.predict.x, 0); }

  if (p->type == MPC_TYPE_CHECK)    { return 1 + mpc_nodecount_unretained(p->data.check.x, 0); }
  if (p->type == MPC_TYPE_CHECK_WITH) { return 1 + mpc_nodecount_unretained(p->data.check_with.x, 0); }

  if (p->type == MPC_TYPE_NOT)   { return 1 + mpc_nodecount_unretained(p->data.not.x, 0); }
  if (p->type == MPC_TYPE_MAYBE) { return 1 + mpc_nodecount_unretained(p->data.not.x, 0); }

  if (p->type == MPC_TYPE_MANY)  { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }
  if (p->type == MPC_TYPE_MANY1) { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }
  if (p->type == MPC_TYPE_COUNT) { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }

  if (p->type == MPC_TYPE_OR) {
    total = 1;
    for(i = 0; i < p->data.or.n; i++) {
      total += mpc_nodecount_unretained(p->data.or.xs[i], 0);
    }
    return total;
  }

  if (p->type == MPC_TYPE_AND) {
    total = 1;
    for(i = 0; i < p->data.and.n; i++) {
      total += mpc_nodecount_unretained(p->data.and.xs[i], 0);
    }
    return total;
  }

  return 1;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
leaq 0x3520(%rip), %rax      # 0xd25c
movl $0x1, %ebx
testl %esi, %esi
jne 0x9d4b
cmpb $0x0, 0x31(%rdi)
jne 0x9d74
movzbl 0x30(%rdi), %edx
addl $-0x5, %edx
cmpl $0x15, %edx
ja 0x9d76
movl $0x8, %ecx
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movl $0x18, %ecx
movq (%rdi,%rcx), %rdi
incl %ebp
xorl %esi, %esi
jmp 0x9d41
xorl %ebx, %ebx
addl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movslq 0x8(%rdi), %r14
testq %r14, %r14
jle 0x9d76
movq 0x18(%rdi), %r15
movl $0x1, %ebx
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
xorl %esi, %esi
callq 0x9d2b
addl %eax, %ebx
incq %r12
cmpq %r12, %r14
jne 0x9d98
jmp 0x9d76
movslq 0x8(%rdi), %r14
testq %r14, %r14
jle 0x9d76
movq 0x10(%rdi), %r15
movl $0x1, %ebx
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
xorl %esi, %esi
callq 0x9d2b
addl %eax, %ebx
incq %r12
cmpq %r12, %r14
jne 0x9dc4
jmp 0x9d76
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/libs/stdin.c
// Function: stdin_read
uint8_t* stdin_read(size_t* size) {
  size_t max = chunk_size;
  size_t offset = 0;
  uint8_t* buffer = malloc(max);

  // Read stdin into a auto-growing buffer
  while (true) {
    ssize_t bytes_read = read(0, buffer + offset, max - offset);
    if (bytes_read < 0) return NULL;
    if (bytes_read == 0) break;
    offset += bytes_read;
    if (offset == max) {
      max = offset + chunk_size;
      buffer = realloc(buffer, max);
    }
  }

  // Optionally record size
  if (size) *size = offset;

  // Clean up freespace and add null terminator
  buffer = realloc(buffer, offset + 1);
  buffer[offset] = 0;

  return buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x100, %r15d           # imm = 0x100
movl $0x100, %edi            # imm = 0x100
callq 0x21a0
movq %rax, %r14
xorl %r12d, %r12d
leaq (%r14,%r12), %rsi
movq %r15, %rdx
subq %r12, %rdx
xorl %edi, %edi
callq 0x2130
testq %rax, %rax
js 0xa460
je 0xa467
addq %rax, %r12
xorl %ebp, %ebp
cmpq %r15, %r12
jne 0xa46c
leaq 0x100(%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d0
movq %rax, %r14
jmp 0xa46c
movl $0x1, %ebp
jmp 0xa46c
movl $0x3, %ebp
testl %ebp, %ebp
je 0xa426
cmpl $0x3, %ebp
jne 0xa491
testq %rbx, %rbx
je 0xa47d
movq %r12, (%rbx)
leaq 0x1(%r12), %rsi
movq %r14, %rdi
callq 0x21d0
movb $0x0, (%rax,%r12)
jmp 0xa493
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/compile.c
// Function: parse_number
uint32_t parse_number(mpc_ast_t* ast) {
  if (is(ast, "number|decimal|regex")) {
    return atoi(ast->contents);
  }
  if (is(ast, "number|boolean|string")) {
    return !strcmp(ast->contents, "true");
  }
  if (is(ast, "number|hex|regex")) {
    return strtol(ast->contents + 2, NULL, 16);
  }
  assert(false); // Unknown tag for number
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x319c(%rip), %rsi      # 0xd64d
callq 0xa53a
testb %al, %al
je 0xa4c4
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x2210
leaq 0x3197(%rip), %rsi      # 0xd662
movq %rbx, %rdi
callq 0xa53a
testb %al, %al
je 0xa4f2
movq 0x8(%rbx), %rdi
leaq 0x3196(%rip), %rsi      # 0xd678
callq 0x2150
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0xa519
leaq 0x3184(%rip), %rsi      # 0xd67d
movq %rbx, %rdi
callq 0xa53a
testb %al, %al
je 0xa51b
movq 0x8(%rbx), %rdi
addq $0x2, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2180
popq %rbx
retq
leaq 0x316c(%rip), %rdi      # 0xd68e
leaq 0x316b(%rip), %rsi      # 0xd694
leaq 0x3172(%rip), %rcx      # 0xd6a2
movl $0x52, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/compile.c
// Function: generate_block
static void generate_block(mpc_ast_t* ast) {
  if (ast->children_num > 3) pushchar(DO);
  for (int i = 1; i < ast->children_num - 1; i++) {
    generate_statement(ast->children[i]);
  }
  if (ast->children_num > 3) pushchar(END);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x4, 0x30(%rdi)
jl 0xa9d7
movzwl 0x881e(%rip), %eax      # 0x131e0
leal 0x1(%rax), %ecx
movw %cx, 0x8814(%rip)       # 0x131e0
leaq 0x882d(%rip), %rcx      # 0x13200
movb $-0x54, (%rax,%rcx)
cmpl $0x3, 0x30(%rbx)
jl 0xaa21
movl $0x1, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xbe6d
incq %r14
movslq 0x30(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r14
jl 0xa9e3
cmpl $0x3, %eax
jle 0xaa21
movzwl 0x87d4(%rip), %eax      # 0x131e0
leal 0x1(%rax), %ecx
movw %cx, 0x87ca(%rip)       # 0x131e0
leaq 0x87e3(%rip), %rcx      # 0x13200
movb $-0x53, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/compile.c
// Function: generate_number
static void generate_number(uint32_t num) {
  // fprintf(stderr, "Generate Num %u - %08x\n", num, num);
  if (num < 0x80) {
    pushchar((char)num);
  }
  else if (num < 0x100) {
    pushchar(UINT8);
    pushchar(num);
  }
  else if (num < 0x10000) {
    pushchar(UINT16);
    pushchar(num >> 8);
    pushchar(num);
  }
  else if (num < 0x1000000) {
    pushchar(UINT24);
    pushchar(num >> 16);
    pushchar(num >> 8);
    pushchar(num);
  }
  else {
    pushchar(UINT32);
    pushchar(num >> 24);
    pushchar(num >> 16);
    pushchar(num >> 8);
    pushchar(num);
  }
}

// Assembly:
movl %edi, %eax
cmpl $0x7f, %edi
ja 0xc1ec
movzwl 0x6ffd(%rip), %ecx      # 0x131e0
movl %ecx, %edx
incl %edx
jmp 0xc2e6
cmpl $0xff, %eax
ja 0xc217
movzwl 0x6fe6(%rip), %edx      # 0x131e0
leal 0x1(%rdx), %ecx
movw %cx, 0x6fdc(%rip)       # 0x131e0
leaq 0x6ff5(%rip), %rsi      # 0x13200
movb $-0x80, (%rdx,%rsi)
addl $0x2, %edx
jmp 0xc2e6
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0xc252
movzwl 0x6fbb(%rip), %edx      # 0x131e0
leal 0x1(%rdx), %esi
movw %si, 0x6fb1(%rip)       # 0x131e0
leaq 0x6fca(%rip), %rdi      # 0x13200
movb $-0x7f, (%rdx,%rdi)
leal 0x2(%rdx), %ecx
movw %cx, 0x6f9c(%rip)       # 0x131e0
movzwl %si, %esi
movb %ah, (%rsi,%rdi)
addl $0x3, %edx
jmp 0xc2e6
pushq %rbx
movzwl 0x6f86(%rip), %edx      # 0x131e0
leal 0x1(%rdx), %ecx
leal 0x2(%rdx), %edi
movl $0xffff, %esi           # imm = 0xFFFF
movw %cx, 0x6f74(%rip)       # 0x131e0
movl %ecx, %r8d
andl %esi, %r8d
leal 0x3(%rdx), %ecx
andl %edi, %esi
leaq 0x6f82(%rip), %rbx      # 0x13200
cmpl $0xffffff, %eax         # imm = 0xFFFFFF
ja 0xc2aa
movb $-0x7e, (%rdx,%rbx)
movl %eax, %r9d
shrl $0x10, %r9d
movw %di, 0x6f49(%rip)       # 0x131e0
movb %r9b, (%r8,%rbx)
movw %cx, 0x6f3e(%rip)       # 0x131e0
movb %ah, (%rsi,%rbx)
addl $0x4, %edx
jmp 0xc2e5
movb $-0x7d, (%rdx,%rbx)
movl %eax, %r9d
shrl $0x18, %r9d
movw %di, 0x6f24(%rip)       # 0x131e0
movb %r9b, (%r8,%rbx)
movl %eax, %edi
shrl $0x10, %edi
movw %cx, 0x6f14(%rip)       # 0x131e0
movb %dil, (%rsi,%rbx)
movzwl %cx, %ecx
leal 0x4(%rdx), %esi
movw %si, 0x6f03(%rip)       # 0x131e0
movb %ah, (%rcx,%rbx)
addl $0x5, %edx
movl %esi, %ecx
popq %rbx
movw %dx, 0x6ef3(%rip)       # 0x131e0
movzwl %cx, %ecx
leaq 0x6f09(%rip), %rdx      # 0x13200
movb %al, (%rcx,%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/compile.c
// Function: generate_call
static void generate_call(mpc_ast_t* ast) {
  // Loop up the function being called
  fn_def_t fn = fns[match_fn(ast->children[0]->contents)];
  uint8_t nargs = (ast->children_num - 2) / 2;
  if (nargs != fn.nargs) {
    fprintf(stderr, "%s requires %d args, but you supplied %d\n", fn.name, fn.nargs, nargs);
    exit(-1);
  }
  // Emit the initial opcode
  pushchar(fn.opcode);

  for (int i = 0; i < nargs; i++) {
    generate_statement(ast->children[i * 2 + 2]);
  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq (%rax), %rax
movq 0x8(%rax), %r14
leaq 0x19f9(%rip), %rdi      # 0xdd50
movl $0x10, %r15d
leaq 0x69ac(%rip), %r12      # 0x12d10
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0xc389
movq (%r15,%r12), %rdi
addq $0x10, %r15
cmpq $0xd0, %r15
jne 0xc364
movq %r14, %rdi
callq 0x2344
movl -0x8(%r15,%r12), %ecx
movl 0x30(%rbx), %eax
movl %eax, %edx
addl $-0x2, %edx
shrl $0x1f, %edx
addl %edx, %eax
addl $-0x2, %eax
shrl %eax
movzbl %al, %r14d
cmpl %ecx, %r14d
jne 0xc3f8
movb -0x4(%r15,%r12), %al
movzwl 0x6e2b(%rip), %ecx      # 0x131e0
leal 0x1(%rcx), %edx
movw %dx, 0x6e21(%rip)       # 0x131e0
leaq 0x6e3a(%rip), %rdx      # 0x13200
movb %al, (%rcx,%rdx)
testl %r14d, %r14d
je 0xc3ec
shll $0x4, %r14d
xorl %r15d, %r15d
movq 0x38(%rbx), %rax
movq 0x10(%rax,%r15), %rdi
callq 0xbe6d
addq $0x10, %r15
cmpq %r15, %r14
jne 0xc3d5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq -0x10(%r15,%r12), %rdx
movq 0x6bf4(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x1918(%rip), %rsi      # 0xdd26
movl %r14d, %r8d
xorl %eax, %eax
callq 0x2160
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2240
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/compile.c
// Function: generate_sum
static void generate_sum(mpc_ast_t* ast) {
  switch (ast->children[1]->contents[0]) {
    case '-': pushchar(SUB); break;
    case '+': pushchar(ADD); break;
    default: assert(false);
  }
  generate_statement(ast->children[0]);
  generate_statement(ast->children[2]);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %ecx
movb $-0x7b, %al
cmpl $0x2d, %ecx
je 0xc443
cmpl $0x2b, %ecx
jne 0xc478
movb $-0x7c, %al
movzwl 0x6d96(%rip), %ecx      # 0x131e0
leal 0x1(%rcx), %edx
movw %dx, 0x6d8c(%rip)       # 0x131e0
leaq 0x6da5(%rip), %rdx      # 0x13200
movb %al, (%rcx,%rdx)
movq 0x38(%rbx), %rax
movq (%rax), %rdi
callq 0xbe6d
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rdi
popq %rbx
jmp 0xbe6d
leaq 0x120f(%rip), %rdi      # 0xd68e
leaq 0x120e(%rip), %rsi      # 0xd694
leaq 0x1911(%rip), %rcx      # 0xdd9e
movl $0xaf, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/compile.c
// Function: generate_product
static void generate_product(mpc_ast_t* ast) {
  switch (ast->children[1]->contents[0]) {
    case '*': pushchar(MUL); break;
    case '/': pushchar(DIV); break;
    case '%': pushchar(MOD); break;
    default: assert(false);
  }
  generate_statement(ast->children[0]);
  generate_statement(ast->children[2]);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %ecx
cmpl $0x25, %ecx
je 0xc4bf
movb $-0x7a, %al
cmpl $0x2a, %ecx
je 0xc4c1
cmpl $0x2f, %ecx
jne 0xc4f6
movb $-0x79, %al
jmp 0xc4c1
movb $-0x78, %al
movzwl 0x6d18(%rip), %ecx      # 0x131e0
leal 0x1(%rcx), %edx
movw %dx, 0x6d0e(%rip)       # 0x131e0
leaq 0x6d27(%rip), %rdx      # 0x13200
movb %al, (%rcx,%rdx)
movq 0x38(%rbx), %rax
movq (%rax), %rdi
callq 0xbe6d
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rdi
popq %rbx
jmp 0xbe6d
leaq 0x1191(%rip), %rdi      # 0xd68e
leaq 0x1190(%rip), %rsi      # 0xd694
leaq 0x18b2(%rip), %rcx      # 0xddbd
movl $0xba, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/compile.c
// Function: generate_equality
static void generate_equality(mpc_ast_t* ast) {
  const char* op = ast->children[1]->contents;
  if (!strcmp("<", op)) pushchar(LT);
  else if (!strcmp(">", op)) pushchar(GT);
  else if (!strcmp("<=", op)) pushchar(LTE);
  else if (!strcmp(">=", op)) pushchar(GTE);
  else if (!strcmp("==", op)) pushchar(EQ);
  else if (!strcmp("!=", op)) pushchar(NEQ);
  else assert(-1);
  generate_statement(ast->children[0]);
  generate_statement(ast->children[2]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
leaq 0x103e(%rip), %rdi      # 0xd56d
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0xc59e
leaq 0x169f(%rip), %rdi      # 0xdbe1
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0xc5a2
leaq 0x188b(%rip), %rdi      # 0xdde0
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0xc5a6
leaq 0x187b(%rip), %rdi      # 0xdde3
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0xc5aa
leaq 0x1877(%rip), %rdi      # 0xddf2
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0xc5ae
leaq 0x1858(%rip), %rdi      # 0xdde6
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
jne 0xc5cb
movb $-0x72, %al
jmp 0xc5b0
movb $-0x76, %al
jmp 0xc5b0
movb $-0x77, %al
jmp 0xc5b0
movb $-0x74, %al
jmp 0xc5b0
movb $-0x75, %al
jmp 0xc5b0
movb $-0x73, %al
movzwl 0x6c29(%rip), %ecx      # 0x131e0
leal 0x1(%rcx), %edx
movw %dx, 0x6c1f(%rip)       # 0x131e0
leaq 0x6c38(%rip), %rdx      # 0x13200
movb %al, (%rcx,%rdx)
movq 0x38(%rbx), %rax
movq (%rax), %rdi
callq 0xbe6d
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbe6d
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/compile.c
// Function: generate_value
static void generate_value(mpc_ast_t* ast) {
  if (ast->children[0]->contents[0] == '(') {
    return generate_statement(ast->children[1]);
  }
  mpc_ast_print_to(ast, stderr);
  exit(-1);
}

// Assembly:
movq 0x38(%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
cmpb $0x28, (%rcx)
jne 0xc63f
movq 0x8(%rax), %rdi
jmp 0xbe6d
pushq %rax
movq 0x69b1(%rip), %rax      # 0x12ff8
movq (%rax), %rsi
callq 0x7dba
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2240
// File: /workspace/github_c_makefile_star2_O1/creationix[P]color-control/src/compile.c
// Function: intern_ident
static uint8_t intern_ident(const char* ident) {
  for (int i = 0; i < 8; i++) {
    if (!names[i]) {
      names[i] = ident;
      // fprintf(stderr, "Found %s at %d\n", ident, i);
      return i;
    }
    if (!strcmp(names[i], ident)) {
      // fprintf(stderr, "Added %s at %d\n", ident, i);
      return i;
    }
  }
  return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x16ba8(%rip), %r15     # 0x23210
xorl %ebx, %ebx
movq (%r15), %rdi
testq %rdi, %rdi
je 0xc68f
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0xc692
incq %rbx
addq $0x8, %r15
cmpq $0x8, %rbx
jne 0xc66a
movb $-0x1, %bl
jmp 0xc692
movq %r14, (%r15)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yurrriq[P]knrc/src/unambiguous.c
// Function: main
int main()
{
    int c;

    while ((c = getchar()) != EOF) {
        if (c == '\t')
            fputs("\\t", stdout);
        else if (c == '\b')
            fputs("\\b", stdout);
        else if (c == '\\')
            fputs("\\\\", stdout);
        else
            putchar(c);
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x2e75(%rip), %r12      # 0x3fe0
leaq 0xe95(%rip), %rbx       # 0x2007
leaq 0xe91(%rip), %r14       # 0x200a
leaq 0xe84(%rip), %r15       # 0x2004
callq 0x1050
cmpl $0x8, %eax
jle 0x11a2
cmpl $0x5c, %eax
je 0x11b2
cmpl $0x9, %eax
jne 0x11c5
movq (%r12), %rsi
movq %r15, %rdi
callq 0x1040
jmp 0x1180
jne 0x11c0
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x1040
jmp 0x1180
movq (%r12), %rsi
movq %r14, %rdi
callq 0x1040
jmp 0x1180
cmpl $-0x1, %eax
je 0x11ce
movl %eax, %edi
callq 0x1030
jmp 0x1180
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/./edge264_bitstream.c
// Function: cabac_start
static int cabac_start(Edge264Context *ctx) {
	// reclaim bits from cache while realigning with CPB on a byte boundary
	int extra_bits = SIZE_BIT - 1 - ctz(ctx->t._gb.lsb_cache);
	int shift = extra_bits & 7;
	int ret = shift > 0 && (ssize_t)ctx->t._gb.msb_cache >> (SIZE_BIT - shift) != -1; // return 1 if not all alignment bits are ones
	ctx->t._gb.codIOffset = shld(ctx->t._gb.lsb_cache, ctx->t._gb.msb_cache, shift); // codIOffset and msb_cache are the same memory slot
	ctx->t._gb.lsb_cache >>= (SIZE_BIT - extra_bits) & (SIZE_BIT - 1);
	while (extra_bits >= 8) {
		int32_t i = 0;
		if ((intptr_t)(ctx->t._gb.end - ctx->t._gb.CPB) >= 0)
			memcpy(&i, ctx->t._gb.CPB - 4, 4);
		ctx->t._gb.CPB -= 1 + ((big_endian32(i) & 0xffffff) == 3);
		ctx->t._gb.lsb_cache >>= 8;
		extra_bits -= 8;
	}
	ctx->t._gb.codIRange = (size_t)510 << (SIZE_BIT - 9);
	ctx->t._gb.codIOffset = (ctx->t._gb.codIOffset < ctx->t._gb.codIRange) ? ctx->t._gb.codIOffset : ctx->t._gb.codIRange - 1; // protection against invalid bitstream
	return ret;
}

// Assembly:
movq 0x10(%rdi), %r8
tzcntq %r8, %rdx
xorl $0x3f, %edx
movl %edx, %ecx
andl $0x7, %ecx
je 0x7f86
movl %ecx, %eax
negb %al
sarxq %rax, 0x18(%rdi), %rsi
xorl %eax, %eax
cmpq $-0x1, %rsi
setne %al
jmp 0x7f88
xorl %eax, %eax
pushq %rbx
movq 0x18(%rdi), %rsi
movq %rsi, -0x8(%rsp)
shldq %cl, %r8, %rsi
movq %rsi, 0x18(%rdi)
movl %edx, %ecx
negb %cl
shrq %cl, 0x10(%rdi)
cmpl $0x8, %edx
jb 0x7ff5
movq (%rdi), %rcx
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %r9
addl $0x8, %edx
movl $0xffffff00, %r10d      # imm = 0xFFFFFF00
cmpq %rcx, %r8
js 0x7fd8
movl -0x4(%rcx), %ebx
andl %r10d, %ebx
xorl %r11d, %r11d
cmpl $0x3000000, %ebx        # imm = 0x3000000
sete %r11b
notq %r11
jmp 0x7fdf
movq $-0x1, %r11
addq %r11, %rcx
movq %rcx, (%rdi)
shrq $0x8, %r9
movq %r9, 0x10(%rdi)
addl $-0x8, %edx
cmpl $0xf, %edx
jg 0x7fbb
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
movq %rcx, 0x10(%rdi)
movabsq $-0x100000000000001, %rcx # imm = 0xFEFFFFFFFFFFFFFF
cmpq %rcx, %rsi
cmovbq %rsi, %rcx
movq %rcx, 0x18(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/./edge264_bitstream.c
// Function: get_ue16
static noinline unsigned get_ue16(Edge264GetBits *gb, unsigned upper) {
	unsigned v = clz(gb->msb_cache | (size_t)1 << (SIZE_BIT / 2)) * 2 + 1; // [1..SIZE_BIT-1]
	unsigned ret = minu((gb->msb_cache >> (SIZE_BIT - v)) - 1, upper);
	gb->msb_cache = shld(gb->lsb_cache, gb->msb_cache, v);
	if (gb->lsb_cache <<= v)
		return ret;
	return refill(gb, ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %r15
movq %r15, %rcx
btsq $0x20, %rcx
lzcntq %rcx, %rcx
leal 0x1(,%rcx,2), %r14d
movq %r15, 0x8(%rsp)
movq %r15, %rdx
movl %r14d, %ecx
shldq %cl, %rax, %rdx
movq %rdx, 0x18(%rdi)
shlxq %r14, 0x10(%rdi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
jne 0xd03b
callq 0xeb81
negb %r14b
shrxq %r14, %r15, %rax
decl %eax
cmpl %ebx, %eax
cmovael %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/./edge264_bitstream.c
// Function: get_uv
static noinline unsigned get_uv(Edge264GetBits *gb, unsigned v) {
	unsigned ret = gb->msb_cache >> (SIZE_BIT - v);
	if (SIZE_BIT == 32 && __builtin_expect(v == 32, 0)) {
		gb->msb_cache = gb->lsb_cache;
		gb->lsb_cache = 0;
	} else {
		gb->msb_cache = shld(gb->lsb_cache, gb->msb_cache, v);
		gb->lsb_cache <<= v;
	}
	if (gb->lsb_cache)
		return ret;
	return refill(gb, ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %r14
movq %r14, (%rsp)
movq %r14, %rdx
movl %esi, %ecx
shldq %cl, %rax, %rdx
movq %rdx, 0x18(%rdi)
shlxq %rbx, 0x10(%rdi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
jne 0xd087
callq 0xeb81
negb %bl
shrxq %rbx, %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/./edge264_headers.c
// Function: finish_frame
static void finish_frame(Edge264Decoder *dec) {
	int non_base_view = dec->non_base_views >> dec->currPic & 1;
	if (dec->pic_reference_flags & 1 << dec->currPic) {
		dec->PrevRefFrameNum[non_base_view] = dec->FrameNums[dec->currPic];
		dec->prevPicOrderCnt[non_base_view] = dec->FieldOrderCnt[0][dec->currPic];
	}
	unsigned other_views = non_base_view ? ~dec->non_base_views : dec->non_base_views;
	dec->reference_flags = (dec->reference_flags & other_views) | dec->pic_reference_flags;
	dec->long_term_flags = (dec->long_term_flags & other_views) | dec->pic_long_term_flags;
	dec->LongTermFrameIdx_v[0] = dec->pic_LongTermFrameIdx_v[0];
	dec->LongTermFrameIdx_v[1] = dec->pic_LongTermFrameIdx_v[1];
	dec->prevPic = dec->currPic;
	dec->currPic = -1;
}

// Assembly:
movl 0x78(%rdi), %ecx
movl 0x24(%rdi), %eax
movl 0x70(%rdi), %edx
shrxl %eax, %ecx, %esi
btl %eax, %edx
jae 0xd0cb
movsbq %al, %r8
movl %esi, %r9d
andl $0x1, %r9d
movl 0x7c(%rdi,%r8,4), %r10d
movl %r10d, 0x3c(%rdi,%r9,4)
movl 0x3d0(%rdi,%r8,4), %r8d
movl %r8d, 0x48(%rdi,%r9,4)
andl $0x1, %esi
negl %esi
xorl %esi, %ecx
movl 0x5c(%rdi), %esi
andl %ecx, %esi
orl %edx, %esi
movl %esi, 0x5c(%rdi)
andl 0x60(%rdi), %ecx
orl 0x74(%rdi), %ecx
movl %ecx, 0x60(%rdi)
vmovups 0x3b0(%rdi), %ymm0
vmovups %ymm0, 0x390(%rdi)
movb %al, 0x25(%rdi)
movb $-0x1, 0x24(%rdi)
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/./edge264_headers.c
// Function: alloc_frame
static int alloc_frame(Edge264Decoder *dec, int id) {
	dec->frame_buffers[id] = malloc(dec->frame_size);
	if (dec->frame_buffers[id] == NULL)
		return ENOMEM;
	Edge264Macroblock *m = (Edge264Macroblock *)(dec->frame_buffers[id] + dec->plane_size_Y + dec->plane_size_C);
	int mbs = (dec->sps.pic_width_in_mbs + 1) * dec->sps.pic_height_in_mbs - 1;
	for (int i = 0; i < mbs; i += dec->sps.pic_width_in_mbs + 1) {
		for (int j = i; j < i + dec->sps.pic_width_in_mbs; j++)
			m[j].recovery_bits = 0;
		if (i + dec->sps.pic_width_in_mbs < mbs)
			m[i + dec->sps.pic_width_in_mbs] = unavail_mb;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x34(%rdi), %rdi
callq 0x10f0
movslq %ebp, %rcx
movq %rax, 0x188(%rbx,%rcx,8)
testq %rax, %rax
je 0xd1cb
movzwl 0x534(%rbx), %r14d
leaq 0x1(%r14), %r15
movswq 0x536(%rbx), %r12
imulq %r15, %r12
cmpl $0x2, %r12d
jl 0xd1c7
movslq 0x2c(%rbx), %rcx
movslq 0x30(%rbx), %rdx
addq %rcx, %rdx
leaq (%rax,%rdx), %rcx
movq %rcx, (%rsp)
decq %r12
leaq (%rax,%rdx), %rbp
incq %rbp
imulq $0x130, %r14, %rbx      # imm = 0x130
movl $0x130, %eax            # imm = 0x130
addq %rax, %rbx
xorl %r13d, %r13d
leaq (%r14,%r13), %rax
movq %rbp, %rcx
movq %r13, %rdx
testq %r14, %r14
je 0xd19b
movb $0x0, (%rcx)
incq %rdx
addq $0x130, %rcx            # imm = 0x130
cmpq %rax, %rdx
jb 0xd189
cmpl %eax, %r12d
jle 0xd1bc
imulq $0x130, %rax, %rdi      # imm = 0x130
addq (%rsp), %rdi
movl $0x130, %edx            # imm = 0x130
leaq 0x31f19(%rip), %rsi     # 0x3f0d0
callq 0x10c0
addq %r15, %r13
addq %rbx, %rbp
cmpq %r12, %r13
jl 0xd17a
xorl %eax, %eax
jmp 0xd1d0
movl $0xc, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/./edge264_bitstream.c
// Function: get_u1
static noinline int get_u1(Edge264GetBits *gb) {
	int ret = gb->msb_cache >> (SIZE_BIT - 1);
	gb->msb_cache = shld(gb->lsb_cache, gb->msb_cache, 1);
	if (gb->lsb_cache <<= 1)
		return ret;
	return refill(gb, ret);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rbx
movq %rbx, 0x8(%rsp)
movq %rbx, %rdx
movl $0x1, %ecx
shldq %cl, %rax, %rdx
movq %rdx, 0x18(%rdi)
movq 0x10(%rdi), %rax
addq %rax, %rax
movq %rax, 0x10(%rdi)
jne 0xd213
callq 0xeb81
shrq $0x3f, %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/./edge264_bitstream.c
// Function: get_se16
static noinline int get_se16(Edge264GetBits *gb, int lower, int upper) {
	unsigned v = clz(gb->msb_cache | (size_t)1 << (SIZE_BIT / 2)) * 2 + 1; // [1..SIZE_BIT-1]
	unsigned ue = (gb->msb_cache >> (SIZE_BIT - v)) - 1;
	int ret = min(max((ue & 1) ? ue / 2 + 1 : -(ue / 2), lower), upper);
	gb->msb_cache = shld(gb->lsb_cache, gb->msb_cache, v);
	if (gb->lsb_cache <<= v)
		return ret;
	return refill(gb, ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %r15
movq %r15, %rcx
btsq $0x20, %rcx
lzcntq %rcx, %rcx
leal 0x1(,%rcx,2), %r14d
movq %r15, (%rsp)
movq %r15, %rdx
movl %r14d, %ecx
shldq %cl, %rax, %rdx
movq %rdx, 0x18(%rdi)
shlxq %r14, 0x10(%rdi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
jne 0xd26d
callq 0xeb81
negb %r14b
shrxq %r14, %r15, %rcx
decl %ecx
movl %ecx, %eax
shrl %eax
movl %eax, %edx
negl %edx
incl %eax
testb $0x1, %cl
cmovel %edx, %eax
cmpl %ebp, %eax
cmovlel %ebp, %eax
cmpl %ebx, %eax
cmovgel %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/edge264_headers.c
// Function: parse_access_unit_delimiter_log
int ADD_VARIANT(parse_access_unit_delimiter)(Edge264Decoder *dec, int non_blocking, void(*free_cb)(void*,int), void *free_arg) {
	const char *primary_pic_type_names[8] =
		{"I", "I,P", "I,P,B", "SI", "SI,SP", "I,SI", "I,SI,P,SP", "I,SI,P,SP,B"};
	int primary_pic_type = get_uv(&dec->_gb, 3);
	log_dec(dec, "  primary_pic_type: %u # %s\n",
		primary_pic_type, primary_pic_type_names[primary_pic_type]);
	if (print_dec(dec))
		return ENOTSUP;
	if (!rbsp_end(&dec->_gb))
		return EBADMSG;
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x3, %esi
callq 0x1875d
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2541, %rcx           # imm = 0x2541
ja 0x25636
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movswq %dx, %rsi
movslq %eax, %rcx
leaq 0x124f0(%rip), %rdx     # 0x37b08
movslq (%rdx,%rcx,4), %r8
addq %rdx, %r8
leaq 0x144de(%rip), %rdx     # 0x39b04
movl %eax, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x7cb0(%rbx)
movzwl 0x7cb0(%rbx), %ecx
movw $0x0, 0x7cb0(%rbx)
movl $0x5f, %eax
cmpw $0x2541, %cx            # imm = 0x2541
ja 0x256aa
leaq 0x7cb2(%rbx), %rdi
movq 0x7ca8(%rbx), %rsi
callq *0x7ca0(%rbx)
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rax
movq %rax, %rcx
shrq $0x3f, %rcx
shlxq %rcx, %rax, %rsi
blsrq %rdx, %rdi
movl $0x4a, %eax
orq %rsi, %rdi
jne 0x256aa
tzcntq %rdx, %rax
movl (%rbx), %edx
subl 0x8(%rbx), %edx
addl %ecx, %eax
leal (%rax,%rdx,8), %eax
addl $0xffffff78, %eax       # imm = 0xFFFFFF78
xorl %ecx, %ecx
cmpl $-0x10, %eax
movl $0x4a, %eax
cmovael %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/edge264_headers.c
// Function: parse_nal_unit_header_extension_log
int ADD_VARIANT(parse_nal_unit_header_extension)(Edge264Decoder *dec, int non_blocking, void(*free_cb)(void*,int), void *free_arg) {
	unsigned u = get_uv(&dec->_gb, 24);
	if (u & 1 << 23)
		return ENOTSUP;
	dec->IdrPicFlag = u >> 22 & 1 ^ 1;
	log_dec(dec, "  idr_flag: %u\n"
		"  priority_id: %d\n"
		"  view_id: %d\n"
		"  temporal_id: %d\n"
		"  anchor_pic_flag: %u\n"
		"  inter_view_flag: %u\n",
		dec->IdrPicFlag,
		u >> 16 & 0x3f,
		u >> 6 & 0x3ff,
		u >> 3 & 7,
		u >> 2 & 1,
		u >> 1 & 1);
	if (dec->nal_unit_type == 20)
		return ADD_VARIANT(parse_slice_layer_without_partitioning)(dec, non_blocking, free_cb, free_arg);
	// spec doesn't mention rbsp_trailing_bits at the end of prefix_nal_unit_rbsp
	if (!rbsp_end(&dec->_gb))
		return EBADMSG;
	if (print_dec(dec))
		return ENOTSUP;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl $0x18, %esi
callq 0x1875d
movl %eax, %r10d
movl $0x5f, %eax
btl $0x17, %r10d
jb 0x257f8
xorl %ecx, %ecx
btl $0x16, %r10d
setae %al
setae 0x23(%rbx)
movzwl 0x7cb0(%rbx), %edx
cmpq $0x2541, %rdx           # imm = 0x2541
ja 0x2576b
leaq (%rbx,%rdx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %esi           # imm = 0x2542
subl %edx, %esi
movswq %si, %rsi
movb %al, %cl
movl %r10d, %r8d
shrl $0x10, %r8d
andl $0x3f, %r8d
movl %r10d, %r9d
shrl $0x6, %r9d
andl $0x3ff, %r9d            # imm = 0x3FF
movl %r10d, %r11d
shrl $0x3, %r11d
andl $0x7, %r11d
movl %r10d, %r12d
shrl $0x2, %r12d
andl $0x1, %r12d
shrl %r10d
andl $0x1, %r10d
subq $0x8, %rsp
leaq 0x143ce(%rip), %rdx     # 0x39b21
xorl %eax, %eax
pushq %r10
pushq %r12
pushq %r11
callq 0x1070
addq $0x20, %rsp
addw %ax, 0x7cb0(%rbx)
cmpb $0x14, 0x22(%rbx)
jne 0x25789
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1178
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rax
movq %rax, %rcx
shrq $0x3f, %rcx
shlxq %rcx, %rax, %rsi
blsrq %rdx, %rdi
movl $0x4a, %eax
orq %rsi, %rdi
jne 0x257f8
tzcntq %rdx, %rdx
movl (%rbx), %esi
subl 0x8(%rbx), %esi
addl %ecx, %edx
leal (%rdx,%rsi,8), %ecx
addl $0xffffff78, %ecx       # imm = 0xFFFFFF78
cmpl $-0x10, %ecx
jb 0x257f8
movzwl 0x7cb0(%rbx), %ecx
movw $0x0, 0x7cb0(%rbx)
movl $0x5f, %eax
cmpw $0x2541, %cx            # imm = 0x2541
ja 0x257f8
leaq 0x7cb2(%rbx), %rdi
movq 0x7ca8(%rbx), %rsi
callq *0x7ca0(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/edge264.c
// Function: edge264_find_start_code
const uint8_t *edge264_find_start_code(const uint8_t *buf, const uint8_t *end, int four_byte) {
	const i8x16 *p = (i8x16 *)((uintptr_t)buf & -16);
	four_byte = four_byte != 0;
	i8x16 zero = {};
	i8x16 c1 = set8(1);
	i8x16 lo0 = {};
	i8x16 v = *p;
	i8x16 hi0 = (v == zero) & shlv128(set8(-1), (uintptr_t)buf & 15);
	while (1) {
		#if defined(__SSE2__)
			unsigned m = movemask(shrd128(lo0, hi0, 14) & shrd128(lo0, hi0, 15) & (v == c1));
			if (m) {
				const uint8_t *res = (uint8_t *)p - 2 - four_byte + __builtin_ctz(m);
				if (*res == 0)
					return minp(res, end);
			}
		#elif defined(__ARM_NEON)
			uint64_t m = (uint64_t)vshrn_n_u16(shrd128(lo0, hi0, 14) & shrd128(lo0, hi0, 15) & (v == c1), 4);
			if (m) {
				const uint8_t *res = (uint8_t *)p - 2 - four_byte + (__builtin_ctzll(m) >> 2);
				if (*res == 0)
					return minp(res, end);
			}
		#endif
		if ((intptr_t)(end - (uint8_t *)++p) <= 0)
			return end;
		lo0 = hi0;
		hi0 = ((v = *p) == zero);
	}
}

// Assembly:
movq %rdi, %rcx
andq $-0x10, %rcx
vmovdqa (%rcx), %xmm0
vptestnmb %xmm0, %xmm0, %k1
vpxor %xmm1, %xmm1, %xmm1
andl $0xf, %edi
leaq 0x25cbb(%rip), %rax     # 0x34130
subq %rdi, %rax
vpcmpeqd %xmm2, %xmm2, %xmm2
vpshufb 0x10(%rax), %xmm2, %xmm2 {%k1} {z}
xorl %edi, %edi
negl %edx
sbbq %rdi, %rdi
vpbroadcastb 0x25532(%rip), %xmm3 # 0x339c5
vpxor %xmm4, %xmm4, %xmm4
vpalignr $0xe, %xmm4, %xmm2, %xmm5 # xmm5 = xmm4[14,15],xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
vpalignr $0xf, %xmm4, %xmm2, %xmm6 # xmm6 = xmm4[15],xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
vpand %xmm6, %xmm5, %xmm5
vpcmpeqb %xmm3, %xmm0, %k0
vpmovb2m %xmm5, %k1
ktestw %k1, %k0
je 0xe4e3
kandw %k1, %k0, %k0
kmovd %k0, %edx
leaq (%rcx,%rdi), %r8
tzcntl %edx, %edx
addq %r8, %rdx
addq $-0x2, %rdx
cmpq %rsi, %rdx
movq %rsi, %r8
cmovsq %rdx, %r8
cmpb $0x0, (%rdx)
cmoveq %r8, %rax
je 0xe509
addq $0x10, %rcx
movq %rsi, %rdx
subq %rcx, %rdx
testq %rdx, %rdx
jle 0xe502
vmovdqa (%rcx), %xmm0
vmovdqa %xmm2, %xmm4
vpcmpeqb %xmm1, %xmm0, %xmm2
movb $0x1, %dl
jmp 0xe50b
xorl %edx, %edx
movq %rsi, %rax
jmp 0xe50b
xorl %edx, %edx
testb %dl, %dl
jne 0xe497
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/edge264.c
// Function: ignore_NAL
static int ignore_NAL(Edge264Decoder *dec, int non_blocking, void(*free_cb)(void*,int), void *free_arg) {
	if (dec->log_arg) {
		dec->log_pos = 0;
		dec->log_cb(dec->log_buf, dec->log_arg);
	}
	return 0;
}

// Assembly:
movq 0x7ca8(%rdi), %rsi
testq %rsi, %rsi
je 0xe7df
pushq %rax
movq %rdi, %rax
movw $0x0, 0x7cb0(%rdi)
addq $0x7cb2, %rdi           # imm = 0x7CB2
callq *0x7ca0(%rax)
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/edge264.c
// Function: edge264_flush
void edge264_flush(Edge264Decoder *dec) {
	if (dec == NULL)
		return;
	if (dec->n_threads)
		pthread_mutex_lock(&dec->lock);
	// FIXME interrupt all threads
	dec->currPic = dec->prevPic = -1;
	dec->PrevRefFrameNum[0] = dec->PrevRefFrameNum[1] = -1;
	dec->prevPicOrderCnt[0] = dec->prevPicOrderCnt[1] = 0;
	dec->reference_flags = dec->long_term_flags = dec->output_flags = dec->non_base_views = 0;
	for (unsigned b = dec->busy_tasks; b; b &= b - 1) {
		Edge264Task *t = dec->tasks + __builtin_ctz(b);
		if (t->free_cb)
			t->free_cb(t->free_arg, 0);
	}
	dec->busy_tasks = dec->pending_tasks = dec->ready_tasks = 0;
	dec->task_dependencies_v[0] = dec->task_dependencies_v[1] = dec->task_dependencies_v[2] = dec->task_dependencies_v[3] = (i32x4){};
	dec->taskPics_v = set8(-1);
	if (dec->n_threads)
		pthread_mutex_unlock(&dec->lock);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xe8b0
movq %rdi, %rbx
cmpb $0x0, 0x20(%rdi)
je 0xe804
leaq 0x1590(%rbx), %rdi
callq 0x1160
movw $0xffff, 0x24(%rbx)     # imm = 0xFFFF
movq $-0x1, 0x3c(%rbx)
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movl %eax, 0x78(%rbx)
movl %eax, 0x64(%rbx)
movq %rax, 0x5c(%rbx)
movzwl 0x1648(%rbx), %ebp
testl %ebp, %ebp
je 0xe861
leaq 0x17a0(%rbx), %r14
tzcntl %ebp, %eax
imulq $0x650, %rax, %rcx      # imm = 0x650
movq 0x160(%r14,%rcx), %rax
testq %rax, %rax
je 0xe85a
addq %r14, %rcx
movq 0x168(%rcx), %rdi
xorl %esi, %esi
callq *%rax
blsrl %ebp, %ebp
jne 0xe834
movw $0x0, 0x164c(%rbx)
movl $0x0, 0x1648(%rbx)
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %ymm0, 0x1750(%rbx)
vmovdqu %ymm0, 0x1770(%rbx)
vpcmpeqd %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x1790(%rbx)
cmpb $0x0, 0x20(%rbx)
je 0xe8b0
addq $0x1590, %rbx           # imm = 0x1590
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
vzeroupper
jmp 0x10e0
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/edge264.c
// Function: edge264_free
void edge264_free(Edge264Decoder **pdec) {
	Edge264Decoder *dec;
	if (pdec != NULL && (dec = *pdec) != NULL) {
		*pdec = NULL;
		if (dec->n_threads) {
			for (int i = 0; i < dec->n_threads; i++)
				pthread_cancel(dec->threads[i]);
			pthread_mutex_destroy(&dec->lock);
			pthread_cond_destroy(&dec->task_ready);
			pthread_cond_destroy(&dec->task_progress);
			pthread_cond_destroy(&dec->task_complete);
		}
		for (int i = 0; i < 32; i++) {
			if (dec->frame_buffers[i] != NULL)
				free(dec->frame_buffers[i]);
		}
		free(dec);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe95d
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xe95d
movq $0x0, (%rdi)
cmpb $0x0, 0x20(%rbx)
je 0xe931
cmpb $0x0, 0x20(%rbx)
jle 0xe901
xorl %r14d, %r14d
movq 0x1510(%rbx,%r14,8), %rdi
callq 0x1130
incq %r14
movsbq 0x20(%rbx), %rax
cmpq %rax, %r14
jl 0xe8e7
leaq 0x1590(%rbx), %rdi
callq 0x1060
leaq 0x15b8(%rbx), %rdi
callq 0x1110
leaq 0x15e8(%rbx), %rdi
callq 0x1110
leaq 0x1618(%rbx), %rdi
callq 0x1110
movl $0x31, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0xe945
callq 0x1030
incq %r14
cmpq $0x51, %r14
jne 0xe937
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/./edge264_mvpred.c
// Function: decode_P_skip
static noinline void decode_P_skip(Edge264Context *ctx) {
	mb->f.inter_eqs_s = little_endian32(0x1b5fbbff);
	mb->refPic_s[0] = ((i32x4)set8(ctx->t.RefPicList_v[0][0]))[0];
	mb->refPic_s[1] = -1;
	int refIdxA = mbA->refIdx[1];
	int refIdxB = mbB->refIdx[2];
	int mvA = mbA->mvs_s[5];
	int mvB = mbB->mvs_s[10];
	i16x8 mv = {};
	if ((refIdxA | mvA) && (refIdxB | mvB) && !(ctx->unavail4x4[0] & 3)) {
		int refIdxC;
		if (__builtin_expect(ctx->unavail4x4[5] & 4, 0)) {
			refIdxC = mbD->refIdx[3];
			mv = (i32x4){mbD->mvs_s[15]};
		} else {
			refIdxC = mbC->refIdx[2];
			mv = (i32x4){mbC->mvs_s[10]};
		}
		// B/C unavailability (->A) was ruled out, thus not tested here
		int eq = !refIdxA + !refIdxB * 2 + !refIdxC * 4;
		if (__builtin_expect(0xe9 >> eq & 1, 1)) {
			mv = median16((i32x4){mvA}, (i32x4){mvB}, mv);
		} else if (eq != 4) {
			mv = (i32x4){(eq == 1) ? mvA : mvB};
		}
	}
	i16x8 mvs = broadcast32(mv, 0);
	mb->mvs_v[0] = mb->mvs_v[1] = mb->mvs_v[2] = mb->mvs_v[3] = mvs;
	mb->mvs_v[4] = mb->mvs_v[5] = mb->mvs_v[6] = mb->mvs_v[7] = (i16x8){};
	decode_inter(ctx, 0, 16, 16);
}

// Assembly:
movq 0x680(%rdi), %rax
movl $0x1b5fbbff, 0x2c(%rax) # imm = 0x1B5FBBFF
vpbroadcastb 0x1a0(%rdi), %xmm0
movq 0x680(%rdi), %rax
vmovd %xmm0, 0x18(%rax)
movq 0x680(%rdi), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq 0x688(%rdi), %rax
movsbl 0x11(%rax), %edx
movl 0xc4(%rax), %eax
movl %eax, %ecx
orl %edx, %ecx
vpxor %xmm0, %xmm0, %xmm0
vpxor %xmm1, %xmm1, %xmm1
je 0xf672
movq 0x690(%rdi), %rcx
movsbl 0x12(%rcx), %esi
movl 0xd8(%rcx), %ecx
movl %ecx, %r8d
orl %esi, %r8d
je 0xf672
testb $0x3, 0x6d0(%rdi)
jne 0xf672
testb $0x4, 0x6d5(%rdi)
jne 0xf6fd
movq 0x698(%rdi), %r9
leaq 0x12(%r9), %r8
addq $0xd8, %r9
vmovd (%r9), %xmm1
xorl %r9d, %r9d
testb %dl, %dl
sete %r9b
xorl %edx, %edx
testb %sil, %sil
sete %dl
leal (%r9,%rdx,2), %edx
xorl %esi, %esi
cmpb $0x0, (%r8)
sete %sil
leal (%rdx,%rsi,4), %edx
movl $0xe9, %esi
btl %edx, %esi
jae 0xf714
vmovd %eax, %xmm2
vmovd %ecx, %xmm3
vpmaxsw %xmm3, %xmm2, %xmm4
vpminsw %xmm1, %xmm4, %xmm1
vpminsw %xmm3, %xmm2, %xmm2
vpmaxsw %xmm2, %xmm1, %xmm1
vpbroadcastd %xmm1, %xmm1
movq 0x680(%rdi), %rax
vmovdqa %xmm1, 0xe0(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm1, 0xd0(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm1, 0xc0(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm1, 0xb0(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm0, 0x120(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm0, 0x110(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm0, 0x100(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm0, 0xf0(%rax)
xorl %esi, %esi
movl $0x10, %edx
movl $0x10, %ecx
jmp 0xf76d
movq 0x6a0(%rdi), %r9
leaq 0x13(%r9), %r8
addq $0xec, %r9
jmp 0xf625
cmpl $0x4, %edx
je 0xf672
cmpl $0x1, %edx
cmovel %eax, %ecx
vmovd %ecx, %xmm1
jmp 0xf672
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_inter_residual_cabac
static void CAFUNC(parse_inter_residual)
{
	static const uint8_t me_inter[48] = {0, 1, 32, 8, 4, 128, 2, 40, 36, 136, 132, 172, 174, 44, 168, 164, 140, 12, 160, 173, 42, 38, 138, 134, 34, 10, 6, 130, 46, 170, 166, 142, 33, 9, 5, 129, 41, 37, 137, 133, 45, 169, 165, 141, 13, 161, 14, 162};
	CACALL(parse_coded_block_pattern, me_inter);
	
	if ((mb->bits[0] & 0xac) && ctx->transform_8x8_mode_flag) {
		mb->f.transform_size_8x8_flag = CACOND(get_u1(&ctx->t._gb), get_ae(ctx, 399 + ctx->inc.transform_size_8x8_flag));
		log_mb(ctx, "    transform_size_8x8_flag: %u\n", mb->f.transform_size_8x8_flag);
	}
	
	#if CABAC
		ctx->nC_inc_v[0] = ctx->nC_inc_v[1] = ctx->nC_inc_v[2] = (i8x16){};
	#endif
	CAJUMP(parse_NxN_residual);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x30f8b
movq 0x680(%rbx), %rax
testb $-0x54, 0x8(%rax)
je 0x30f6b
cmpb $0x0, 0xdc0(%rbx)
je 0x30f6b
movsbl 0x6c4(%rbx), %esi
addl $0x18f, %esi            # imm = 0x18F
movq %rbx, %rdi
callq 0x306b3
movq 0x680(%rbx), %rcx
movb %al, 0x24(%rcx)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x30f6b
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
movq 0x680(%rbx), %rax
movsbl 0x24(%rax), %ecx
leaq 0x96b8(%rip), %rdx      # 0x3a615
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x710(%rbx)
vmovaps %ymm0, 0x700(%rbx)
movq %rbx, %rdi
popq %rbx
vzeroupper
jmp 0x310f2
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_coded_block_pattern_cabac
static void CAFUNC(parse_coded_block_pattern, const uint8_t *map_me)
{
	// Luma prefix
	#if !CABAC
		int cbp = map_me[get_ue16(&ctx->t._gb, 47)];
		mb->bits[0] |= cbp & 0xac;
	#else
		int bits = mb->bits[0];
		bits |= get_ae(ctx, 76 - (bits      & 3)) << 5;
		bits |= get_ae(ctx, 76 - (bits >> 5 & 3)) << 3;
		bits |= get_ae(ctx, 76 - (bits >> 4 & 3)) << 2;
		bits |= get_ae(ctx, 76 - (bits >> 2 & 3)) << 7;
		mb->bits[0] = bits;
	#endif
	
	// Chroma suffix
	if ((ctx->t.ChromaArrayType == 1 || ctx->t.ChromaArrayType == 2) &&
		CACOND(cbp & 3, get_ae(ctx, 77 + ctx->inc.CodedBlockPatternChromaDC)))
	{
		mb->f.CodedBlockPatternChromaDC = 1;
		mb->f.CodedBlockPatternChromaAC = CACOND(cbp >> 1 & 1, get_ae(ctx, 81 + ctx->inc.CodedBlockPatternChromaAC));
	}
	
	log_mb(ctx, "    coded_block_pattern: %u\n",
		(mb->bits[0] >> 5 & 1) | (mb->bits[0] >> 2 & 2) | (mb->bits[0] & 4) | (mb->bits[0] >> 4 & 8) |
		(mb->f.CodedBlockPatternChromaDC + mb->f.CodedBlockPatternChromaAC) << 4);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x680(%rdi), %rax
movl 0x8(%rax), %r15d
movl %r15d, %eax
andl $0x3, %eax
movl $0x4c, %ebp
movl $0x4c, %esi
subl %eax, %esi
callq 0x306b3
movl %eax, %r14d
shll $0x5, %r14d
orl %r15d, %r14d
movl %r14d, %eax
shrl $0x5, %eax
andl $0x3, %eax
movl $0x4c, %esi
subl %eax, %esi
movq %rbx, %rdi
callq 0x306b3
movl %eax, %r15d
shll $0x3, %r15d
movl %r14d, %eax
shrl $0x4, %eax
andl $0x3, %eax
movl $0x4c, %esi
subl %eax, %esi
movq %rbx, %rdi
callq 0x306b3
leal (%r15,%rax,4), %r15d
orl %r14d, %r15d
movl %r15d, %eax
shrl $0x2, %eax
andl $0x3, %eax
subl %eax, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x306b3
shll $0x7, %eax
orl %r15d, %eax
movq 0x680(%rbx), %rcx
movl %eax, 0x8(%rcx)
movb 0x2a(%rbx), %al
decb %al
cmpb $0x1, %al
ja 0x3106a
movsbl 0x6c6(%rbx), %esi
addl $0x4d, %esi
movq %rbx, %rdi
callq 0x306b3
testl %eax, %eax
je 0x3106a
movq 0x680(%rbx), %rax
movb $0x1, 0x26(%rax)
movsbl 0x6c7(%rbx), %esi
addl $0x51, %esi
movq %rbx, %rdi
callq 0x306b3
movq 0x680(%rbx), %rcx
movb %al, 0x27(%rcx)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x310e7
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
movq 0x680(%rbx), %rax
movl 0x8(%rax), %edx
movl %edx, %ecx
shrl $0x5, %ecx
andl $0x1, %ecx
movl %edx, %r8d
shrl $0x2, %r8d
andl $0x2, %r8d
movl %edx, %r9d
andl $0x4, %r9d
orl %r8d, %r9d
orl %ecx, %r9d
shrl $0x4, %edx
andl $0x8, %edx
orl %r9d, %edx
movsbl 0x26(%rax), %r8d
movsbl 0x27(%rax), %ecx
addl %r8d, %ecx
shll $0x4, %ecx
orl %edx, %ecx
leaq 0x955d(%rip), %rdx      # 0x3a636
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_mb_qp_delta_cabac
static void CAFUNC(parse_mb_qp_delta)
{
	#if !CABAC
		int mb_qp_delta = get_se16(&ctx->t._gb, -26, 25); // FIXME QpBdOffset
		if (mb_qp_delta) {
			int sum = ctx->t.QP[0] + mb_qp_delta;
			int QP_Y = (sum < 0) ? sum + 52 : (sum >= 52) ? sum - 52 : sum;
			mb->QP_s = ctx->t.QP_s = (i8x4){QP_Y, ctx->QP_C[0][QP_Y], ctx->QP_C[1][QP_Y]};
		}
	#else
		int mb_qp_delta_nz = get_ae(ctx, 60 + ctx->mb_qp_delta_nz);
		ctx->mb_qp_delta_nz = mb_qp_delta_nz;
		int mb_qp_delta = 0;
		if (mb_qp_delta_nz) {
			unsigned count = 1, ctxIdx = 62;
			while (get_ae(ctx, ctxIdx) && count < 52) // FIXME QpBdOffset
				count++, ctxIdx = 63;
			mb_qp_delta = count & 1 ? count / 2 + 1 : -(count / 2);
			int sum = ctx->t.QP[0] + mb_qp_delta;
			int QP_Y = (sum < 0) ? sum + 52 : (sum >= 52) ? sum - 52 : sum;
			mb->QP_s = ctx->t.QP_s = (i8x4){QP_Y, ctx->QP_C[0][QP_Y], ctx->QP_C[1][QP_Y]};
		}
	#endif
	log_mb(ctx, "    mb_qp_delta: %d\n", mb_qp_delta);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsbl 0x651(%rdi), %esi
addl $0x3c, %esi
callq 0x1680d
movb %al, 0x651(%rbx)
testl %eax, %eax
je 0x1742e
movl $0x3e, %esi
xorl %ebp, %ebp
incl %ebp
movq %rbx, %rdi
callq 0x1680d
testl %eax, %eax
je 0x173d0
movl $0x3f, %esi
cmpl $0x34, %ebp
jb 0x173b8
movl %ebp, %eax
shrl %eax
leal 0x1(%rax), %ecx
negl %eax
testb $0x1, %bpl
cmovnel %ecx, %eax
movsbl 0x50(%rbx), %ecx
leal (%rax,%rcx), %edx
addl $-0x34, %edx
leal (%rax,%rcx), %esi
addl $0x34, %esi
addl %ecx, %eax
cmpl $0x34, %eax
cmovll %eax, %edx
testl %eax, %eax
cmovnsl %edx, %esi
movslq %esi, %rax
movzbl %al, %ecx
vmovd %ecx, %xmm0
vpinsrb $0x1, 0x1ae0(%rbx,%rax), %xmm0, %xmm0
vpinsrb $0x2, 0x1b20(%rbx,%rax), %xmm0, %xmm0
vmovd %xmm0, 0x50(%rbx)
movq 0x680(%rbx), %rax
vmovd %xmm0, 0x4(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq