LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x134b
callq 0x11f0
movl $0x1, %edi
callq 0x10c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1090
movq %rax, -0x18(%rbp)
callq 0x1030
cmpl $0x0, (%rax)
je 0x1396
callq 0x1030
movl (%rax), %edi
callq 0x10d0
movq %rax, %rsi
leaq 0xd45(%rip), %rdi       # 0x20ca
movb $0x0, %al
callq 0x1050
movl $0x1, %edi
callq 0x10c0
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x1458
leaq -0x24(%rbp), %rdi
callq 0x1080
cmpl $0x0, %eax
jge 0x13d9
movq 0x2c38(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xd0b(%rip), %rdi       # 0x20d5
callq 0x1060
movl $0x1, %edi
callq 0x10c0
callq 0x10e0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x1438
movslq -0x1c(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x140f
movl -0x24(%rbp), %edi
callq 0x1270
movl -0x20(%rbp), %edi
movl $0x1, %esi
callq 0x12c0
jmp 0x1417
movl -0x20(%rbp), %edi
callq 0x1270
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x10b0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
movl -0x20(%rbp), %edi
callq 0x1270
movl -0x24(%rbp), %edi
xorl %esi, %esi
callq 0x12c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x139d
movl $0x0, -0x34(%rbp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq -0x2c(%rbp), %rsi
xorl %edx, %edx
callq 0x10a0
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
jle 0x14a2
movl -0x2c(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x14a0
movl -0x2c(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
je 0x14a0
movl -0x2c(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x34(%rbp)
jmp 0x145f
movl -0x34(%rbp), %edi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/9-File/getchar_eof.c
// Function: main
int main(void)
{
	char c;
	unsigned long long count = 0;
	while(1)
	{
		c = getchar();
		if(c == EOF)
			break;
		else
			count++;
	}
	printf("EOF is reached. Read %lld bytes.\n", count);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
callq 0x1040
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $-0x1, %eax
jne 0x117a
jmp 0x1188
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1167
movq -0x10(%rbp), %rsi
leaq 0xe71(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x834a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2230
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8326
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x100, -0x18(%rbp)     # imm = 0x100
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
xorl %edi, %edi
callq 0x20f0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0xc4d5
movq $0x0, -0x8(%rbp)
jmp 0xc550
cmpq $0x0, -0x30(%rbp)
jne 0xc4de
jmp 0xc515
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xc513
movq -0x20(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2190
movq %rax, -0x28(%rbp)
jmp 0xc4a9
cmpq $0x0, -0x10(%rbp)
je 0xc527
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x2190
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5226(%rip), %rsi      # 0x117ed
callq 0xc680
testb $0x1, %al
jne 0xc5d2
jmp 0xc5e7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21d0
movl %eax, -0x4(%rbp)
jmp 0xc677
movq -0x10(%rbp), %rdi
leaq 0x5210(%rip), %rsi      # 0x11802
callq 0xc680
testb $0x1, %al
jne 0xc5fd
jmp 0xc623
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x520c(%rip), %rsi      # 0x11818
callq 0x2110
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xc677
movq -0x10(%rbp), %rdi
leaq 0x51ef(%rip), %rsi      # 0x1181d
callq 0xc680
testb $0x1, %al
jne 0xc639
jmp 0xc658
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x2, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x2140
movl %eax, -0x4(%rbp)
jmp 0xc677
leaq 0x51cf(%rip), %rdi      # 0x1182e
leaq 0x51ce(%rip), %rsi      # 0x11834
movl $0x52, %edx
leaq 0x51d0(%rip), %rcx      # 0x11842
callq 0x20c0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x30(%rax)
jle 0xcdcb
movw 0xa413(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0xa405(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0xa4e9(%rip), %rax      # 0x172b0
movb $-0x54, (%rax,%rcx)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x30(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xce03
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xf810
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xcdd2
movq -0x8(%rbp), %rax
cmpl $0x3, 0x30(%rax)
jle 0xce32
movw 0xa3ac(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0xa39e(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0xa482(%rip), %rax      # 0x172b0
movb $-0x53, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/compile.c
// Function: ends_with
static bool ends_with(const char *str, const char *suffix) {
  if (!str || !suffix) return false;
  size_t lenstr = strlen(str);
  size_t lensuffix = strlen(suffix);
  if (lensuffix > lenstr) return false;
  return strncmp(str + lenstr - lensuffix, suffix, lensuffix) == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf79e
cmpq $0x0, -0x18(%rbp)
jne 0xf7a4
movb $0x0, -0x1(%rbp)
jmp 0xf7f7
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2090
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xf7ce
movb $0x0, -0x1(%rbp)
jmp 0xf7f7
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
xorl %eax, %eax
subq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2040
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/compile.c
// Function: generate_for
static void generate_for(mpc_ast_t* ast) {

  // Emit the FOR for the proper loop variable
  uint8_t id = intern_ident(ast->children[1]->contents);
  pushchar(FOR0 + id);

  // Emit start and stop ranges
  uint32_t num = parse_number(ast->children[3]);
  mpc_ast_t* range = mpc_ast_get_child(ast, "range|>");
  if (range) {
    generate_number(num);
    uint32_t end = parse_number(range->children[1]);
    if (!strcmp(range->children[0]->contents, "...")) end--;
    generate_number(end);
  }
  else {
    generate_number(0);
    generate_number(num - 1);
  }

  // Emit iteration step count
  mpc_ast_t* by = mpc_ast_get_child(ast, "by|>");
  generate_number(by ? parse_number(by->children[1]) : 1);

  return generate_block(mpc_ast_get_child(ast, "block|>"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x104e0
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
addl $0xa2, %eax
movb %al, %dl
movw 0x741a(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x740c(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x74f0(%rip), %rax      # 0x172b0
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rdi
callq 0xc5b0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x20cb(%rip), %rsi      # 0x11ead
callq 0x9550
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xfe41
movl -0x10(%rbp), %edi
callq 0xfa60
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdi
callq 0xc5b0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x2091(%rip), %rsi      # 0x11eb5
callq 0x2110
cmpl $0x0, %eax
jne 0xfe37
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0xfa60
jmp 0xfe53
xorl %edi, %edi
callq 0xfa60
movl -0x10(%rbp), %edi
subl $0x1, %edi
callq 0xfa60
movq -0x8(%rbp), %rdi
leaq 0x205b(%rip), %rsi      # 0x11eb9
callq 0x9550
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xfe84
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdi
callq 0xc5b0
movl %eax, -0x2c(%rbp)
jmp 0xfe8e
movl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xfe8e
movl -0x2c(%rbp), %edi
callq 0xfa60
movq -0x8(%rbp), %rdi
leaq 0x201d(%rip), %rsi      # 0x11ebe
callq 0x9550
movq %rax, %rdi
callq 0xcd90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x10570
movslq %eax, %rcx
leaq 0x7276(%rip), %rax      # 0x171d0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
subl $0x2, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0xffbc
movq 0x7063(%rip), %rax      # 0x16ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movl -0x10(%rbp), %ecx
movzbl -0x19(%rbp), %r8d
leaq 0x1f1b(%rip), %rsi      # 0x11ec6
movb $0x0, %al
callq 0x2120
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
movb -0xc(%rbp), %dl
movw 0x71fa(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x71ec(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x72d0(%rip), %rax      # 0x172b0
movb %dl, (%rax,%rcx)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1001c
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x20(%rbp), %ecx
shll %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0xf810
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xffea
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x2b, %eax
je 0x1008a
jmp 0x10059
movl -0xc(%rbp), %eax
subl $0x2d, %eax
jne 0x100b1
jmp 0x10063
movw 0x7156(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x7148(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x722c(%rip), %rax      # 0x172b0
movb $-0x7b, (%rax,%rcx)
jmp 0x100d0
movw 0x712f(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x7121(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x7205(%rip), %rax      # 0x172b0
movb $-0x7c, (%rax,%rcx)
jmp 0x100d0
leaq 0x1776(%rip), %rdi      # 0x1182e
leaq 0x1775(%rip), %rsi      # 0x11834
movl $0xaf, %edx
leaq 0x1e73(%rip), %rcx      # 0x11f3e
callq 0x20c0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rdi
callq 0xf810
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rdi
callq 0xf810
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x25, %eax
je 0x1018b
jmp 0x10129
movl -0xc(%rbp), %eax
subl $0x2a, %eax
je 0x1013d
jmp 0x10133
movl -0xc(%rbp), %eax
subl $0x2f, %eax
je 0x10164
jmp 0x101b2
movw 0x707c(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x706e(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x7152(%rip), %rax      # 0x172b0
movb $-0x7a, (%rax,%rcx)
jmp 0x101d1
movw 0x7055(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x7047(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x712b(%rip), %rax      # 0x172b0
movb $-0x79, (%rax,%rcx)
jmp 0x101d1
movw 0x702e(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x7020(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x7104(%rip), %rax      # 0x172b0
movb $-0x78, (%rax,%rcx)
jmp 0x101d1
leaq 0x1675(%rip), %rdi      # 0x1182e
leaq 0x1674(%rip), %rsi      # 0x11834
movl $0xba, %edx
leaq 0x1d91(%rip), %rcx      # 0x11f5d
callq 0x20c0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rdi
callq 0xf810
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rdi
callq 0xf810
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x14d4(%rip), %rdi      # 0x116ff
callq 0x2110
cmpl $0x0, %eax
jne 0x1025f
movw 0x6f84(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x6f76(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x705a(%rip), %rax      # 0x172b0
movb $-0x76, (%rax,%rcx)
jmp 0x1039d
movq -0x10(%rbp), %rsi
leaq 0x1b17(%rip), %rdi      # 0x11d81
callq 0x2110
cmpl $0x0, %eax
jne 0x1029e
movw 0x6f45(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x6f37(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x701b(%rip), %rax      # 0x172b0
movb $-0x77, (%rax,%rcx)
jmp 0x1039b
movq -0x10(%rbp), %rsi
leaq 0x1cd7(%rip), %rdi      # 0x11f80
callq 0x2110
cmpl $0x0, %eax
jne 0x102dd
movw 0x6f06(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x6ef8(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x6fdc(%rip), %rax      # 0x172b0
movb $-0x74, (%rax,%rcx)
jmp 0x10399
movq -0x10(%rbp), %rsi
leaq 0x1c9b(%rip), %rdi      # 0x11f83
callq 0x2110
cmpl $0x0, %eax
jne 0x10319
movw 0x6ec7(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x6eb9(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x6f9d(%rip), %rax      # 0x172b0
movb $-0x75, (%rax,%rcx)
jmp 0x10397
movq -0x10(%rbp), %rsi
leaq 0x1c62(%rip), %rdi      # 0x11f86
callq 0x2110
cmpl $0x0, %eax
jne 0x10355
movw 0x6e8b(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x6e7d(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x6f61(%rip), %rax      # 0x172b0
movb $-0x73, (%rax,%rcx)
jmp 0x10395
movq -0x10(%rbp), %rsi
leaq 0x1c29(%rip), %rdi      # 0x11f89
callq 0x2110
cmpl $0x0, %eax
jne 0x10391
movw 0x6e4f(%rip), %ax       # 0x171c0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x6e41(%rip)       # 0x171c0
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x6f25(%rip), %rax      # 0x172b0
movb $-0x72, (%rax,%rcx)
jmp 0x10393
jmp 0x10393
jmp 0x10395
jmp 0x10397
jmp 0x10399
jmp 0x1039b
jmp 0x1039d
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rdi
callq 0xf810
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rdi
callq 0xf810
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x104ba
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdi
callq 0xf810
addq $0x10, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
movq 0x6b33(%rip), %rax      # 0x16ff8
movq (%rax), %rsi
callq 0x9480
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x10558
movslq -0x14(%rbp), %rcx
leaq 0x16dbc(%rip), %rax     # 0x272c0
cmpq $0x0, (%rax,%rcx,8)
jne 0x10526
movq -0x10(%rbp), %rdx
movslq -0x14(%rbp), %rcx
leaq 0x16da6(%rip), %rax     # 0x272c0
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
movb %al, -0x1(%rbp)
jmp 0x1055c
movslq -0x14(%rbp), %rcx
leaq 0x16d8f(%rip), %rax     # 0x272c0
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x2110
cmpl $0x0, %eax
jne 0x1054b
movl -0x14(%rbp), %eax
movb %al, -0x1(%rbp)
jmp 0x1055c
jmp 0x1054d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x104f3
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/creationix[P]color-control/src/compile.c
// Function: match_fn
static int match_fn(const char* name) {
  uint8_t i = 0;
  while (fns[i].name) {
    if (!strcmp(fns[i].name, name)) return i;
    i++;
  }
  fprintf(stderr, "No such function %s\n", name);
  exit(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x6c43(%rip), %rax      # 0x171d0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x105d3
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x6c29(%rip), %rax      # 0x171d0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x2110
cmpl $0x0, %eax
jne 0x105c9
movzbl -0x9(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x10580
movq 0x6a1e(%rip), %rax      # 0x16ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1941(%rip), %rsi      # 0x11f29
movb $0x0, %al
callq 0x2120
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1050
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x11e4
cmpl $0x9, -0x8(%rbp)
jne 0x119a
movq 0x2e57(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xe71(%rip), %rdi       # 0x2004
callq 0x1040
jmp 0x11e2
cmpl $0x8, -0x8(%rbp)
jne 0x11b8
movq 0x2e39(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xe56(%rip), %rdi       # 0x2007
callq 0x1040
jmp 0x11e0
cmpl $0x5c, -0x8(%rbp)
jne 0x11d6
movq 0x2e1b(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xe3b(%rip), %rdi       # 0x200a
callq 0x1040
jmp 0x11de
movl -0x8(%rbp), %edi
callq 0x1030
jmp 0x11e0
jmp 0x11e2
jmp 0x116f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movabsq $0x100000000, %rax      # imm = 0x100000000
orq 0x18(%rcx), %rax
lzcntq %rax, %rax
shll %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x40, %ecx
subl -0x30(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
subq $0x1, %rax
movl %eax, %ecx
movl -0x2c(%rbp), %eax
movl %ecx, -0x4(%rbp)
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x179a2
movl -0x4(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x179a8
movl -0x8(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movl -0x30(%rbp), %eax
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movl -0x1c(%rbp), %ecx
shldq %cl, %rdx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x10(%rax), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq -0x40(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x17a15
movl -0x34(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x17a24
movq -0x28(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1ca60
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tvlabs[P]edge264/./edge264_headers.c
// Function: finish_frame
static void finish_frame(Edge264Decoder *dec) {
	if (dec->pic_reference_flags & 1 << dec->currPic)
		dec->prevPicOrderCnt = dec->FieldOrderCnt[0][dec->currPic];
	unsigned other_views = (dec->second_views & 1 << dec->currPic) ? ~dec->second_views : dec->second_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
movq -0x8(%rbp), %rcx
movsbl 0x24(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x17a72
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movsbq 0x24(%rcx), %rcx
movl 0x3c0(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x8(%rbp), %rax
movl 0x68(%rax), %eax
movq -0x8(%rbp), %rcx
movsbl 0x24(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x17aa0
movq -0x8(%rbp), %rax
movl 0x68(%rax), %eax
xorl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x17aaa
movq -0x8(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %ecx
andl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
orl 0x60(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %ecx
andl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
orl 0x64(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
vmovdqa 0x3a0(%rax), %xmm0
movq -0x8(%rbp), %rax
vmovdqa %xmm0, 0x380(%rax)
movq -0x8(%rbp), %rax
vmovdqa 0x3b0(%rax), %xmm0
movq -0x8(%rbp), %rax
vmovdqa %xmm0, 0x390(%rax)
movq -0x8(%rbp), %rax
movb 0x24(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x25(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x24(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x40, %ecx
subl -0x24(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movl -0x24(%rbp), %eax
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movl -0x14(%rbp), %ecx
shldq %cl, %rdx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x17bbe
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x17bcd
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x1ca60
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq 0x34(%rax), %rdi
callq 0x70f0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x178(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, 0x178(%rax,%rcx,8)
jne 0x17c2e
movl $0xc, -0x4(%rbp)
jmp 0x17d33
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x178(%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movslq 0x2c(%rcx), %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movslq 0x30(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x524(%rax), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
movswl 0x526(%rcx), %ecx
imull %ecx, %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x17d2c
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzwl 0x524(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x17ccb
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x130, %rcx, %rcx      # imm = 0x130
addq %rcx, %rax
movb $0x0, 0x1(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x17c93
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x524(%rcx), %ecx
addl %ecx, %eax
cmpl -0x24(%rbp), %eax
jge 0x17d11
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x524(%rcx), %ecx
addl %ecx, %eax
cltq
imulq $0x130, %rax, %rax      # imm = 0x130
addq %rax, %rdi
leaq 0xbf3c9(%rip), %rsi     # 0xd70d0
movl $0x130, %edx            # imm = 0x130
callq 0x70c0
jmp 0x17d13
movq -0x10(%rbp), %rax
movzwl 0x524(%rax), %eax
addl $0x1, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x17c81
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3f, %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movl -0x14(%rbp), %ecx
shldq %cl, %rdx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rax
shlq %rax
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x17db6
movl -0x24(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x17dc5
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1ca60
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movl %edx, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movabsq $0x100000000, %rax      # imm = 0x100000000
orq 0x18(%rcx), %rax
lzcntq %rax, %rax
shll %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x40, %ecx
subl -0x3c(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
subq $0x1, %rax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x17e35
movl -0x40(%rbp), %eax
shrl %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x17e41
movl -0x40(%rbp), %ecx
shrl %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %ecx
movl -0x34(%rbp), %eax
movl %ecx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x17e5d
movl -0x20(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x17e63
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %ecx
movl -0x38(%rbp), %eax
movl %ecx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x17e7f
movl -0x18(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0x17e85
movl -0x1c(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movl -0x3c(%rbp), %eax
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movl -0x14(%rbp), %ecx
shldq %cl, %rdx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x3c(%rbp), %ecx
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x10(%rax), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq -0x58(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x17ef2
movl -0x44(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x17f01
movq -0x30(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x1ca60
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
leaq -0x80(%rbp), %rdi
leaq 0x5ce5b(%rip), %rsi     # 0xd6230
movl $0x40, %edx
callq 0x70c0
movq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0x65e90
movl %eax, -0x84(%rbp)
movq -0x20(%rbp), %rax
movswq 0x7ca0(%rax), %rax
cmpq $0x2542, %rax           # imm = 0x2542
jae 0x7946c
movq -0x20(%rbp), %rdi
addq $0x7ca2, %rdi           # imm = 0x7CA2
movq -0x20(%rbp), %rax
movswl 0x7ca0(%rax), %eax
cltq
addq %rax, %rdi
movq -0x20(%rbp), %rax
movswq 0x7ca0(%rax), %rax
movl $0x2542, %esi           # imm = 0x2542
subq %rax, %rsi
movl -0x84(%rbp), %ecx
movslq -0x84(%rbp), %rax
movq -0x80(%rbp,%rax,8), %r8
leaq 0x56b07(%rip), %rdx     # 0xcff56
movb $0x0, %al
callq 0x7070
movl %eax, %edx
movq -0x20(%rbp), %rax
movswl 0x7ca0(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x7ca0(%rax)
movq -0x20(%rbp), %rdi
callq 0x65e20
cmpl $0x0, %eax
je 0x79486
movl $0x5f, -0x14(%rbp)
jmp 0x79547
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3f, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
tzcntq %rax, %rax
movl %eax, %ecx
movl $0x7f, %eax
subl %ecx, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0xc(%rbp), %ecx
shlq %cl, %rax
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x85(%rbp)
jne 0x79527
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
andq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x85(%rbp)
jne 0x79527
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl -0x10(%rbp), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x85(%rbp)
movb -0x85(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x79540
movl $0x4a, -0x14(%rbp)
jmp 0x79547
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x7c98(%rax)
je 0x1c2e5
movq -0x8(%rbp), %rax
movw $0x0, 0x7ca0(%rax)
movq -0x8(%rbp), %rax
movq 0x7c90(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x7ca2, %rdi           # imm = 0x7CA2
movq -0x8(%rbp), %rcx
movq 0x7c98(%rcx), %rsi
callq *%rax
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c642
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1c642
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x20(%rax)
je 0x1c5f7
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1c5b7
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x1500(%rax,%rcx,8), %rdi
callq 0x7130
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c588
movq -0x10(%rbp), %rdi
addq $0x1580, %rdi           # imm = 0x1580
callq 0x7060
movq -0x10(%rbp), %rdi
addq $0x15a8, %rdi           # imm = 0x15A8
callq 0x7110
movq -0x10(%rbp), %rdi
addq $0x15d8, %rdi           # imm = 0x15D8
callq 0x7110
movq -0x10(%rbp), %rdi
addq $0x1608, %rdi           # imm = 0x1608
callq 0x7110
movl $0x0, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jge 0x1c639
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, 0x178(%rax,%rcx,8)
je 0x1c62c
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq 0x178(%rax,%rcx,8), %rdi
callq 0x7030
jmp 0x1c62e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c5fe
movq -0x10(%rbp), %rdi
callq 0x7030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tvlabs[P]edge264/./edge264_bitstream.c
// Function: refill
static noinline int refill(Edge264GetBits *gb, int ret) {
	size_t bytes = get_bytes(gb, SIZE_BIT >> 3);
	int trailing_bit = ctz(gb->msb_cache); // [0..SIZE_BIT-1]
	gb->msb_cache = (gb->msb_cache ^ (size_t)1 << trailing_bit) | bytes >> (SIZE_BIT - 1 - trailing_bit);
	gb->lsb_cache = (bytes * 2 + 1) << trailing_bit;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x4c850
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
tzcntq %rax, %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x1c(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
xorq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x3f, %ecx
subl -0x1c(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq -0x28(%rbp), %rcx
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
shlq %rax
addq $0x1, %rax
movl -0x1c(%rbp), %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1f5e9(%rip), %rsi     # 0xcf680
callq 0xb0290
movq -0x8(%rbp), %rax
movq 0x680(%rax), %rax
movl 0x8(%rax), %eax
andl $0xac, %eax
cmpl $0x0, %eax
je 0xb016e
movq -0x8(%rbp), %rax
movsbl 0xdc0(%rax), %eax
cmpl $0x0, %eax
je 0xb016e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movsbl 0x6c4(%rax), %esi
addl $0x18f, %esi            # imm = 0x18F
callq 0xae5c0
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x680(%rax), %rax
movb %cl, 0x24(%rax)
movq -0x8(%rbp), %rax
movswq 0x1cd0(%rax), %rax
cmpq $0x1000, %rax           # imm = 0x1000
jae 0xb016c
movq -0x8(%rbp), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movq -0x8(%rbp), %rax
movswl 0x1cd0(%rax), %eax
cltq
addq %rax, %rdi
movq -0x8(%rbp), %rax
movswq 0x1cd0(%rax), %rax
movl $0x1000, %esi           # imm = 0x1000
subq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x680(%rax), %rax
movsbl 0x24(%rax), %ecx
leaq 0x2082e(%rip), %rdx     # 0xd097d
movb $0x0, %al
callq 0x7070
movl %eax, %edx
movq -0x8(%rbp), %rax
movswl 0x1cd0(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x1cd0(%rax)
jmp 0xb016e
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, -0x20(%rbp)
vmovdqa -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
vmovdqa %xmm0, 0x720(%rax)
movq -0x8(%rbp), %rax
vmovdqa %xmm0, 0x710(%rax)
movq -0x8(%rbp), %rax
vmovdqa %xmm0, 0x700(%rax)
movq -0x8(%rbp), %rdi
callq 0xb04a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_intraNxN_pred_mode_cabac
static inline int CAFUNC(parse_intraNxN_pred_mode, int luma4x4BlkIdx)
{
	// dcPredModePredictedFlag is enforced by putting -2
	int intraMxMPredModeA = *((int8_t *)mb->Intra4x4PredMode + ctx->A4x4_int8[luma4x4BlkIdx]);
	int intraMxMPredModeB = *((int8_t *)mb->Intra4x4PredMode + ctx->B4x4_int8[luma4x4BlkIdx]);
	int mode = abs(min(intraMxMPredModeA, intraMxMPredModeB));
	int rem_intra_pred_mode = -1;
	if (CACOND(!get_u1(&ctx->t._gb), !get_ae(ctx, 68))) {
		#if !CABAC
			rem_intra_pred_mode = get_uv(&ctx->t._gb, 3);
		#else
			rem_intra_pred_mode = get_ae(ctx, 69);
			rem_intra_pred_mode += get_ae(ctx, 69) * 2;
			rem_intra_pred_mode += get_ae(ctx, 69) * 4;
		#endif
		mode = rem_intra_pred_mode + (rem_intra_pred_mode >= mode);
	}
	log_mb(ctx, luma4x4BlkIdx ? ",%d" : "%d", rem_intra_pred_mode);
	return mode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x680(%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movswl 0xb40(%rcx,%rdx,2), %ecx
movslq %ecx, %rcx
movsbl 0x30(%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x680(%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movslq 0xb80(%rcx,%rdx,4), %rcx
movsbl 0x30(%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %eax
movl %ecx, -0x4(%rbp)
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0xb2764
movl -0x4(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xb276a
movl -0x8(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x44, %esi
callq 0xae5c0
cmpl $0x0, %eax
jne 0xb27e6
movq -0x10(%rbp), %rdi
movl $0x45, %esi
callq 0xae5c0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x45, %esi
callq 0xae5c0
shll %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x45, %esi
callq 0xae5c0
shll $0x2, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x24(%rbp), %ecx
cmpl -0x20(%rbp), %ecx
setge %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movswq 0x1cd0(%rax), %rax
cmpq $0x1000, %rax           # imm = 0x1000
jae 0xb2861
movq -0x10(%rbp), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movq -0x10(%rbp), %rax
movswl 0x1cd0(%rax), %eax
cltq
addq %rax, %rdi
movq -0x10(%rbp), %rax
movswq 0x1cd0(%rax), %rax
movl $0x1000, %esi           # imm = 0x1000
subq %rax, %rsi
movl -0x14(%rbp), %ecx
leaq 0x1d514(%rip), %rdx     # 0xcfd47
leaq 0x1e311(%rip), %rax     # 0xd0b4b
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movl -0x24(%rbp), %ecx
movb $0x0, %al
callq 0x7070
movl %eax, %edx
movq -0x10(%rbp), %rax
movswl 0x1cd0(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x1cd0(%rax)
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)