LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/router.h
// Function: route::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void add(const std::string pattern, int no){
        // "/page/:num"
        std::vector<std::string> v = cc_split(pattern, "/");
        struct Tree *top = root;

        for(auto i: v)
            if(!i.empty()){
                if(i[0] == ':'){
                    top->catcher = i.substr(1);
                }else{
                    if(!top->to[i]) top->to[i] = new Tree();
                    top = top->to[i];
                }
            }

        top->ending = no;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %rbx
leaq 0x58158(%rip), %rsi     # 0x6958c
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xcb10
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %rbx, %rsi
callq 0xe782
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xcd88
movq 0x766ff(%rip), %rbx     # 0x87b68
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %rbp
leaq 0x48(%rsp), %r12
cmpq %rbp, %r15
je 0x11535
movq %r14, %rdi
movq %r15, %rsi
callq 0xc640
cmpq $0x0, 0x18(%rsp)
je 0x11524
movq 0x10(%rsp), %rax
cmpb $0x3a, (%rax)
jne 0x114c9
movq %r12, %rdi
movq %r14, %rsi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
callq 0xcb30
leaq 0x30(%rbx), %rdi
movq %r12, %rsi
callq 0xc5f0
movq %r12, %rdi
callq 0xcd88
jmp 0x11524
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14dda
cmpq $0x0, (%rax)
jne 0x11516
pushq $0x58
popq %rdi
callq 0xc1f0
movq %rax, %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
andq $0x0, 0x50(%rax)
movq %rax, %rdi
callq 0x14dae
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14dda
movq %r13, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14dda
movq (%rax), %rbx
movq %r14, %rdi
callq 0xcd88
addq $0x20, %r15
jmp 0x11478
movl 0xc(%rsp), %eax
movl %eax, 0x50(%rbx)
leaq 0x30(%rsp), %rdi
callq 0x10156
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcd88
jmp 0x11587
movq %rax, %rbx
jmp 0x11587
jmp 0x1156b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcd88
jmp 0x1157d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x10156
movq %rbx, %rdi
callq 0xc790
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/config.h
// Function: bool ConfigManager::get<bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T get(const std::string& k){
		if(typeid(T).name() == typeid(int).name())
			return configs_int[k];
		else if(typeid(T).name() == typeid(bool).name())
			return configs_bool[k];
		else
			return 0;
	}

// Assembly:
pushq %rax
movq 0x720e6(%rip), %rax     # 0x86fe8
movq 0x8(%rax), %rax
xorl %ecx, %ecx
cmpb $0x2a, (%rax)
sete %cl
addq %rax, %rcx
movq 0x72098(%rip), %rax     # 0x86fb0
movq 0x8(%rax), %rax
xorl %edx, %edx
cmpb $0x2a, (%rax)
sete %dl
addq %rax, %rdx
cmpq %rdx, %rcx
je 0x14f39
addq $0x70, %rdi
callq 0x1a054
movb (%rax), %al
jmp 0x14f48
addq $0x38, %rdi
callq 0x10a12
cmpl $0x0, (%rax)
setne %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/config.h
// Function: ConfigManager::try_set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ConfigManager& try_set(const std::string& k, const std::string& v){
		if(v == "on" || v == "off")
			configs_bool[k] = (v == "on");
		else{
			if(configs_str.find(k) != configs_str.end())
				configs_str[k] = v;
			else if(configs_int.find(k) != configs_int.end())
				configs_int[k] = atol(v.c_str());
		}
		return *this;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x53806(%rip), %rsi     # 0x688f4
movq %rdx, %rdi
callq 0x10fbd
testb %al, %al
jne 0x1510d
leaq 0x4cb35(%rip), %rsi     # 0x61c36
movq %r15, %rdi
callq 0x10fbd
testb %al, %al
je 0x15139
leaq 0x537e0(%rip), %rsi     # 0x688f4
movq %r15, %rdi
callq 0x10fbd
movl %eax, %ebp
leaq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x1a054
movb %bpl, (%rax)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a430
testq %rax, %rax
je 0x15161
movq %rbx, %rdi
movq %r14, %rsi
callq 0x104e4
movq %rax, %rdi
movq %r15, %rsi
callq 0xcc70
jmp 0x1512d
leaq 0x38(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1a45e
testq %rax, %rax
je 0x1512d
movq (%r15), %rdi
callq 0xc730
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
callq 0x10a12
movl %r15d, (%rax)
jmp 0x1512d
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/tags.h
// Function: TemplateManager::load_templates()
int load_templates(){
		DIR *pDIR;
        struct dirent *entry;
        int c = 0;
        std::string root_dir = "./templates/" + lang + "/";

        if(pDIR = opendir(root_dir.c_str()) ){
            while(entry = readdir(pDIR)){
                if( strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0 ){
	                string filename = entry->d_name;

	        		HTMLTemplate tmp;
					tmp.load_file(root_dir + filename);

	            	filename = filename.substr(0, filename.size() - 4);
					m_templates[filename] = tmp;

					c++;
				}

            }
            closedir(pDIR);
        }

        return c;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp            # imm = 0x2A8
movq %rdi, %rbx
leaq 0x30(%rdi), %rdx
leaq 0x4c141(%rip), %rsi     # 0x61cc0
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0x10196
leaq 0x539f6(%rip), %rdx     # 0x6958c
movq %rsp, %rdi
movq %r14, %rsi
callq 0x100f2
leaq 0x80(%rsp), %rdi
callq 0xcd88
movq (%rsp), %rdi
callq 0xc6b0
testq %rax, %rax
je 0x15ca4
movq %rax, %r15
xorl %r14d, %r14d
leaq 0x40(%rsp), %r12
leaq 0x80(%rsp), %r13
movq %r15, %rdi
callq 0xc8b0
testq %rax, %rax
je 0x15c9a
cmpb $0x2e, 0x13(%rax)
jne 0x15bfc
cmpb $0x0, 0x14(%rax)
je 0x15bd3
cmpb $0x2e, 0x14(%rax)
jne 0x15bfc
cmpb $0x0, 0x15(%rax)
je 0x15bd3
addq $0x13, %rax
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0xcb10
movq %r13, %rdi
callq 0x16e66
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %r12, %rdx
callq 0x1a68a
movq %r13, %rdi
leaq 0x20(%rsp), %rbp
movq %rbp, %rsi
callq 0x1aa32
movq %rbp, %rdi
callq 0xcd88
movq 0x48(%rsp), %rcx
addq $-0x4, %rcx
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xcb30
movq %r12, %rdi
movq %rbp, %rsi
callq 0xc5f0
movq %rbp, %rdi
callq 0xcd88
movq %rbx, %rdi
movq %r12, %rsi
callq 0x167bc
movq %rax, %rdi
movq %r13, %rsi
callq 0x1ab64
incl %r14d
movq %r13, %rdi
callq 0x16312
movq %r12, %rdi
callq 0xcd88
jmp 0x15bd3
movq %r15, %rdi
callq 0xc680
jmp 0x15ca7
xorl %r14d, %r14d
movq %rsp, %rdi
callq 0xcd88
movl %r14d, %eax
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
jmp 0x15d0b
jmp 0x15ce9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xcd88
jmp 0x15cec
movq %rax, %rbx
jmp 0x15cf9
jmp 0x15d05
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x16312
leaq 0x40(%rsp), %rdi
callq 0xcd88
jmp 0x15d08
movq %rax, %rbx
movq %rsp, %rdi
callq 0xcd88
movq %rbx, %rdi
callq 0xc790
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/tags.h
// Function: TemplateManager::add_template(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
HTMLTemplate& add_template(const string& name){
		HTMLTemplate tmp;
		std::string root_dir = "./templates/" + lang + "/";

		tmp.load_file(root_dir + name + string(".tpl"));

		m_templates[name] = tmp;

		return m_templates[name]; //*this;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x90(%rsp), %rdi
callq 0x16e66
leaq 0x30(%r14), %rdx
leaq 0x4bf80(%rip), %rsi     # 0x61cc0
leaq 0x10(%rsp), %rdi
callq 0x10196
leaq 0x5383b(%rip), %rdx     # 0x6958c
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x100f2
leaq 0x10(%rsp), %rdi
callq 0xcd88
leaq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq %rbx, %rdx
callq 0x1a68a
leaq 0x4bfd3(%rip), %rsi     # 0x61d56
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xcb10
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x1020c
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1aa32
leaq 0x50(%rsp), %rdi
callq 0xcd88
leaq 0x30(%rsp), %rdi
callq 0xcd88
leaq 0x10(%rsp), %rdi
callq 0xcd88
movq %r14, %rdi
movq %rbx, %rsi
callq 0x167bc
leaq 0x90(%rsp), %rsi
movq %rax, %rdi
callq 0x1ab64
movq %r14, %rdi
movq %rbx, %rsi
callq 0x167bc
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xcd88
leaq 0x90(%rsp), %rdi
callq 0x16312
movq %rbx, %rax
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xcd88
jmp 0x15e36
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xcd88
jmp 0x15e45
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcd88
jmp 0x15e65
jmp 0x15e62
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x15e6a
movq %rax, %rbx
jmp 0x15e6f
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xcd88
leaq 0x90(%rsp), %rdi
callq 0x16312
movq %rbx, %rdi
callq 0xc790
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/tags.h
// Function: HTMLTemplate::HTMLTemplate(HTMLTemplate const&)
HTMLTemplate(const HTMLTemplate& r) {
		str = r.str;
		vec = r.vec;
		fi_pos = r.fi_pos;
		loop_pos = r.loop_pos;
		loop_pos_rev = r.loop_pos_rev;
		if_test = r.if_test;

		i_vars = r.i_vars;
		i_stats = r.i_stats;
		i_loops = r.i_loops;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x17006
movq %r14, 0x30(%rsp)
leaq 0x88(%rbx), %rdi
movq %rdi, 0x28(%rsp)
callq 0x17006
leaq 0xe0(%rbx), %rax
andl $0x0, 0xe0(%rbx)
andq $0x0, 0xe8(%rbx)
movq %rax, 0xf0(%rbx)
movq %rax, 0xf8(%rbx)
andq $0x0, 0x100(%rbx)
andl $0x0, 0x110(%rbx)
leaq 0xd8(%rbx), %rax
movq %rax, 0x18(%rsp)
andq $0x0, 0x118(%rbx)
leaq 0x108(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x110(%rbx), %rax
movq %rax, 0x120(%rbx)
movq %rax, 0x128(%rbx)
andq $0x0, 0x130(%rbx)
leaq 0x138(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x140(%rbx), %rax
andl $0x0, 0x140(%rbx)
andq $0x0, 0x148(%rbx)
movq %rax, 0x150(%rbx)
movq %rax, 0x158(%rbx)
andq $0x0, 0x160(%rbx)
leaq 0x170(%rbx), %rax
andl $0x0, 0x170(%rbx)
andq $0x0, 0x178(%rbx)
movq %rax, 0x180(%rbx)
movq %rax, 0x188(%rbx)
andq $0x0, 0x190(%rbx)
leaq 0x1a0(%rbx), %rax
andl $0x0, 0x1a0(%rbx)
andq $0x0, 0x1a8(%rbx)
movq %rax, 0x1b0(%rbx)
movq %rax, 0x1b8(%rbx)
andq $0x0, 0x1c0(%rbx)
leaq 0x168(%rbx), %r12
andl $0x0, 0x1d0(%rbx)
leaq 0x198(%rbx), %rbp
andq $0x0, 0x1d8(%rbx)
leaq 0x1c8(%rbx), %r14
leaq 0x1d0(%rbx), %rax
movq %rax, 0x1e0(%rbx)
movq %rax, 0x1e8(%rbx)
andq $0x0, 0x1f0(%rbx)
leaq 0x1f8(%rbx), %r15
leaq 0x200(%rbx), %rax
andl $0x0, 0x200(%rbx)
andq $0x0, 0x208(%rbx)
movq %rax, 0x210(%rbx)
movq %rax, 0x218(%rbx)
andq $0x0, 0x220(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xcc70
leaq 0x20(%r13), %rsi
movq 0x20(%rsp), %rdi
callq 0x17294
leaq 0xd8(%r13), %rsi
movq 0x18(%rsp), %rdi
callq 0x1757e
leaq 0x108(%r13), %rsi
movq 0x10(%rsp), %rdi
callq 0x1757e
leaq 0x138(%r13), %rsi
movq 0x8(%rsp), %rdi
callq 0x1757e
leaq 0x168(%r13), %rsi
movq %r12, %rdi
callq 0x17848
leaq 0x198(%r13), %rsi
movq %rbp, %rdi
callq 0x17bce
leaq 0x1c8(%r13), %rsi
movq %r14, %rdi
callq 0x17e5a
addq $0x1f8, %r13            # imm = 0x1F8
movq %r15, %rdi
movq %r13, %rsi
callq 0x181b2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
jmp 0x16ae0
movq %rax, %r13
jmp 0x16aea
movq %rax, %r13
movq %r15, %rdi
callq 0x163b4
movq %r14, %rdi
callq 0x1654a
movq %rbp, %rdi
callq 0x161aa
movq %r12, %rdi
callq 0x165aa
movq 0x8(%rsp), %rdi
callq 0x16620
movq 0x10(%rsp), %rdi
callq 0x16620
movq 0x18(%rsp), %rdi
callq 0x16620
movq 0x28(%rsp), %rdi
callq 0x16668
movq 0x30(%rsp), %rdi
callq 0x16668
movq 0x20(%rsp), %rdi
callq 0x16392
movq %rbx, %rdi
callq 0xcd88
movq %r13, %rdi
callq 0xc790
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/config.h
// Function: ConfigManager::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string trim(const std::string& str){
		std::string::size_type pos = str.find_first_not_of(' ');
		if (pos == std::string::npos)
		{
			return str;
		}
		std::string::size_type pos2 = str.find_last_not_of(' ');
		if (pos2 != std::string::npos)
		{
			return str.substr(pos, pos2 - pos + 1);
		}
		return str.substr(pos);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xca10
cmpq $-0x1, %rax
je 0x1a637
movq %rax, %r15
pushq $0x20
popq %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0xc7b0
cmpq $-0x1, %rax
je 0x1a644
subq %r15, %rax
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
jmp 0x1a650
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc640
jmp 0x1a655
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xcb30
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/tags.h
// Function: HTMLTemplate::load_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void load_file(string s) {
		std::ifstream ifs(s);
		string line, sz;
		while (getline(ifs, line)) sz += trim(line);

		load(sz);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x290, %rsp            # imm = 0x290
movq %rdi, %rbx
leaq 0x88(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0xcbe0
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x48(%rsp), %r15
leaq 0x68(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0xc5d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1aac2
movq %r12, %rdi
movq %r15, %rsi
callq 0x1ac24
movq %r13, %rdi
movq %r12, %rsi
callq 0xc9c0
movq %r12, %rdi
callq 0xcd88
jmp 0x1aa89
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc640
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ac94
leaq 0x28(%rsp), %rdi
callq 0xcd88
leaq 0x8(%rsp), %rdi
callq 0xcd88
leaq 0x48(%rsp), %rdi
callq 0xcd88
leaq 0x88(%rsp), %rdi
callq 0xc070
addq $0x290, %rsp            # imm = 0x290
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x1ab2e
jmp 0x1ab37
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xcd88
jmp 0x1ab3a
jmp 0x1ab37
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xcd88
leaq 0x48(%rsp), %rdi
callq 0xcd88
leaq 0x88(%rsp), %rdi
callq 0xc070
movq %rbx, %rdi
callq 0xc790
nop
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/tags.h
// Function: HTMLTemplate::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static string trim(const string& str)
	{
		string::size_type pos = str.find_first_not_of(' ');
		if (pos == string::npos)
		{
			return str;
		}
		string::size_type pos2 = str.find_last_not_of(' ');
		if (pos2 != string::npos)
		{
			return str.substr(pos, pos2 - pos + 1);
		}
		return str.substr(pos);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xca10
cmpq $-0x1, %rax
je 0x1ac6d
movq %rax, %r15
pushq $0x20
popq %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0xc7b0
cmpq $-0x1, %rax
je 0x1ac7a
subq %r15, %rax
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
jmp 0x1ac86
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc640
jmp 0x1ac8b
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xcb30
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/views/info.cpp
// Function: views::info::render(mg_connection*, char const*)
void render(mg_connection* conn, const char* msg){
        	// cout << msg << ";";
            templates.invoke("site_header").pipe_to(conn).destory();
            templates.invoke("info_page").var("CONTENT", msg).toggle("info_page").pipe_to(conn).destory();
            // cout << msg << ";";
            templates.invoke("site_footer").var("TIME", 0).pipe_to(conn).destory();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4323c(%rip), %rsi     # 0x6196d
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xcb10
leaq 0x69601(%rip), %rdi     # 0x87d48
leaq 0x10(%rsp), %rsi
callq 0x14fb0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x151b6
movq %rax, %rdi
callq 0x15224
leaq 0x10(%rsp), %rdi
callq 0xcd88
leaq 0x4334c(%rip), %rsi     # 0x61ac1
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xcb10
leaq 0x695bd(%rip), %rdi     # 0x87d48
leaq 0x10(%rsp), %rsi
callq 0x14fb0
movq %rax, %r15
leaq 0x437f3(%rip), %rsi     # 0x61f92
leaq 0x30(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xcb10
leaq 0x70(%rsp), %rdi
leaq 0xd(%rsp), %rdx
movq %r14, %rsi
callq 0xcb10
leaq 0x30(%rsp), %rsi
leaq 0x70(%rsp), %rdx
movq %r15, %rdi
callq 0x1505c
movq %rax, %r14
leaq 0x432e5(%rip), %rsi     # 0x61ac1
leaq 0x50(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0xcb10
leaq 0x1c8(%r14), %rdi
leaq 0x50(%rsp), %rsi
callq 0x189cc
movb $0x1, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x151b6
movq %rax, %rdi
callq 0x15224
leaq 0x50(%rsp), %rdi
callq 0xcd88
leaq 0x70(%rsp), %rdi
callq 0xcd88
leaq 0x30(%rsp), %rdi
callq 0xcd88
leaq 0x10(%rsp), %rdi
callq 0xcd88
leaq 0x431ac(%rip), %rsi     # 0x619ed
leaq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0xcb10
leaq 0x694f1(%rip), %rdi     # 0x87d48
leaq 0x10(%rsp), %rsi
callq 0x14fb0
movq %rax, %r14
leaq 0x43149(%rip), %rsi     # 0x619b4
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xcb10
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x15236
movq %rax, %rdi
movq %rbx, %rsi
callq 0x151b6
movq %rax, %rdi
callq 0x15224
leaq 0x30(%rsp), %rdi
callq 0xcd88
leaq 0x10(%rsp), %rdi
callq 0xcd88
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1e8ff
jmp 0x1e8ff
jmp 0x1e8d2
jmp 0x1e8c5
movq %rax, %rbx
jmp 0x1e8e9
jmp 0x1e8d7
jmp 0x1e8ff
jmp 0x1e8ff
jmp 0x1e8d2
movq %rax, %rbx
jmp 0x1e90c
movq %rax, %rbx
jmp 0x1e8f3
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xcd88
leaq 0x70(%rsp), %rdi
callq 0xcd88
leaq 0x30(%rsp), %rdi
callq 0xcd88
jmp 0x1e902
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcd88
movq %rbx, %rdi
callq 0xc790
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/views/list/gallery.cpp
// Function: views::gallery::showGallery(mg_connection*, int, int)
void showGallery(mg_connection* conn, cclong startID, cclong endID){
            struct Thread *r = unq_read_thread(pDb, 0); // get the root thread
            cclong c = 0;

            bool admin_view = is_admin(conn);

            cclong totalThreads = r->childCount;
            // cclong totalPages = 100;

            templates.invoke("site_slogan").pipe_to(conn).destory();

            for(cclong i = totalThreads; i > 0; --i){
                delete r;
                r = unq_read_thread(pDb, i);
                if(strlen(r->imgSrc) == 15 && r->state & NORMAL_DISPLAY) {
                    c++;
                    if (c >= startID && c <= endID){
                        mg_printf_data(conn, "<hr>");
                        views::each_thread(conn, r, SEND_SHOW_REPLY_LINK + SEND_CUT_LONG_COMMENT, admin_view);
                    }
                }
                
                if (c == endID + 1) break;
            }
            if(r) delete r;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdi, %rbx
leaq 0x6732f(%rip), %rbp     # 0x87c18
movq (%rbp), %rdi
xorl %esi, %esi
callq 0xd515
movq %rax, %r15
movq %rbx, %rdi
callq 0xe080
movl %eax, %r14d
movl 0xcc(%r15), %r12d
leaq 0x417b7(%rip), %rsi     # 0x620c7
leaq 0x28(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rdi
callq 0xcb10
leaq 0x6741f(%rip), %rdi     # 0x87d48
movq %r13, %rsi
callq 0x14fb0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x151b6
movq %rbx, 0x20(%rsp)
movq %rax, %rdi
callq 0x15224
leaq 0x28(%rsp), %rdi
callq 0xcd88
movq 0x18(%rsp), %rax
leal 0x1(%rax), %r13d
movzbl %r14b, %eax
movl %eax, 0x10(%rsp)
xorl %ebx, %ebx
testl %r12d, %r12d
jle 0x209f9
movq %r15, %rdi
callq 0xc660
movq (%rbp), %rdi
movl %r12d, %esi
callq 0xd515
movq %rax, %r15
leaq 0xa8(%rax), %rdi
callq 0xc470
cmpq $0xf, %rax
jne 0x2099e
testb $0x1, (%r15)
jne 0x209ae
movl %ebx, %r14d
decl %r12d
movl %r14d, %ebx
cmpl %r13d, %r14d
jne 0x20966
jmp 0x209f9
leal 0x1(%rbx), %r14d
cmpl 0x14(%rsp), %r14d
setl %al
cmpl 0x18(%rsp), %ebx
setge %cl
orb %al, %cl
jne 0x209a1
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
leaq 0x416c8(%rip), %rsi     # 0x6209c
xorl %eax, %eax
callq 0x59649
movq %rbx, %rdi
movq %r15, %rsi
pushq $0x6
popq %rdx
movl 0x10(%rsp), %ecx
leaq 0x46c63(%rip), %r8      # 0x67652
movq %r8, %r9
callq 0x1e914
jmp 0x209a1
testq %r15, %r15
je 0x20a06
movq %r15, %rdi
callq 0xc660
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xcd88
movq %rbx, %rdi
callq 0xc790
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/actions/chat.cpp
// Function: websocket::poll(mg_connection*)
void poll(mg_connection *conn) {
        if(!conn->connection_param) return;

        struct ChatData *d = (struct ChatData *) conn->connection_param;

        string username = cck_verify_ssid(d->ssid);
        if(username.empty()) return;

        struct mg_connection *c;

        if (conn->content_len > 5 && !memcmp(conn->content, "join ", 5)) {
        // Client joined new room
            d->roomID = conn->content[5];
        } else if (conn->content_len > 4 && !memcmp(conn->content, "msg ", 4) &&
                 d->roomID != 0 && d->roomID != '?') {
            broadcast(conn);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq 0x290(%rdi), %r15
testq %r15, %r15
je 0x24900
movq %rdi, %rbx
leaq 0x4(%r15), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xcb10
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe5f4
leaq 0x10(%rsp), %rdi
callq 0xcd88
cmpq $0x0, 0x38(%rsp)
je 0x248f6
movq 0x270(%rbx), %rax
cmpq $0x6, %rax
jb 0x248e0
movq 0x268(%rbx), %r14
leaq 0x3d932(%rip), %rsi     # 0x621f9
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0xc800
testl %eax, %eax
jne 0x248ed
movsbl 0x5(%r14), %eax
movl %eax, (%r15)
jmp 0x248f6
cmpq $0x5, %rax
jne 0x248f6
movq 0x268(%rbx), %r14
cmpl $0x2067736d, (%r14)     # imm = 0x2067736D
je 0x2490a
leaq 0x30(%rsp), %rdi
callq 0xcd88
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl (%r15), %eax
testl %eax, %eax
je 0x248f6
cmpl $0x3f, %eax
je 0x248f6
movq %rbx, %rdi
callq 0x24618
jmp 0x248f6
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x24932
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcd88
jmp 0x2493c
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc790
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./src/actions/kill.cpp
// Function: actions::kill::call(mg_connection*, int, bool)
bool call(mg_connection* conn, int tid, bool admin){
            string username = cck_verify_ssid(conn);
            bool flag = false;

            if (!username.empty()){
                struct Thread* t = unq_read_thread(pDb, tid);

                if (strcmp(t->ssid, username.c_str()) == 0 || admin){
                    unq_delete_thread(pDb, tid);
                    logLog("%s has deleted No.%d", username.c_str(), tid);
                    flag = true;
                }
                else{
                    flag = false;
                }

                if(t) delete t;
            }else
                flag = false;

            return flag;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xe580
cmpq $0x0, 0x8(%r14)
je 0x25104
leaq 0x62b6f(%rip), %r12     # 0x87c18
movq (%r12), %rdi
movl %ebx, %esi
callq 0xd515
movq %rax, %r14
leaq 0x91(%rax), %rdi
movq (%rsp), %rsi
callq 0xc970
testl %eax, %eax
sete %bpl
orb %r15b, %bpl
cmpb $0x1, %bpl
jne 0x250f5
movq (%r12), %rdi
movl %ebx, %esi
callq 0xd576
movq (%rsp), %rsi
leaq 0x3d15c(%rip), %rdi     # 0x62248
movl %ebx, %edx
xorl %eax, %eax
callq 0xeb8f
testq %r14, %r14
je 0x25106
movq %r14, %rdi
callq 0xc660
jmp 0x25106
xorl %ebp, %ebp
movq %rsp, %rdi
callq 0xcd88
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xcd88
movq %rbx, %rdi
callq 0xc790
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlite_lib_shutdown
int unqlite_lib_shutdown(void)
{
	if( sUnqlMPGlobal.nMagic != UNQLITE_LIB_MAGIC ){
		/* Already shut */
		return UNQLITE_OK;
	}
	unqliteCoreShutdown();
	return UNQLITE_OK;
}

// Assembly:
cmpl $0xea1495ba, 0x606bb(%rip) # imm = 0xEA1495BA
jne 0x272a3
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x606a0(%rip), %rdi     # 0x877f0
movl 0x60692(%rip), %eax     # 0x877e8
testl %eax, %eax
jle 0x27179
movq 0x110(%rdi), %rbx
callq 0x2808b
movl 0x6067c(%rip), %eax     # 0x877e8
decl %eax
movl %eax, 0x60674(%rip)     # 0x877e8
movq %rbx, %rdi
jmp 0x27156
leaq 0x60630(%rip), %rdi     # 0x877b0
callq 0x31feb
movq 0x6060c(%rip), %rax     # 0x87798
testq %rax, %rax
je 0x271ca
movq 0x60608(%rip), %rdi     # 0x877a0
testq %rdi, %rdi
je 0x271b7
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x271af
callq *%rcx
movq 0x605e9(%rip), %rax     # 0x87798
andq $0x0, 0x605e9(%rip)     # 0x877a0
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x271c2
callq *%rax
andq $0x0, 0x605ce(%rip)     # 0x87798
andl $0x0, 0x605d7(%rip)     # 0x877a8
cmpq $0x0, 0x6050f(%rip)     # 0x876e8
je 0x271e7
leaq 0x604fe(%rip), %rdi     # 0x876e0
callq 0x27b23
movl $0x1764, 0x60607(%rip)  # imm = 0x1764
cmpl $0xea1495ba, 0x60ef5(%rip) # imm = 0xEA1495BA
jne 0x2729d
movq 0x60ee0(%rip), %rdi     # 0x880e8
movl 0x60ed2(%rip), %eax     # 0x880e0
testl %eax, %eax
jle 0x27231
movq 0x108(%rdi), %rbx
callq 0x3201e
movl 0x60ebc(%rip), %eax     # 0x880e0
decl %eax
movl %eax, 0x60eb4(%rip)     # 0x880e0
movq %rbx, %rdi
jmp 0x2720e
movq 0x60e88(%rip), %rax     # 0x880c0
testq %rax, %rax
je 0x27276
movq 0x60e84(%rip), %rdi     # 0x880c8
testq %rdi, %rdi
je 0x27263
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x2725b
callq *%rcx
movq 0x60e65(%rip), %rax     # 0x880c0
andq $0x0, 0x60e65(%rip)     # 0x880c8
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x2726e
callq *%rax
andq $0x0, 0x60e4a(%rip)     # 0x880c0
andl $0x0, 0x60e53(%rip)     # 0x880d0
cmpq $0x0, 0x60d8b(%rip)     # 0x88010
je 0x27293
leaq 0x60d7a(%rip), %rdi     # 0x88008
callq 0x27b23
movl $0x1928, 0x60e53(%rip)  # imm = 0x1928
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendPoolAlloc
JX9_PRIVATE void * SyMemBackendPoolAlloc(SyMemBackend *pBackend, sxu32 nByte)
{
	void *pChunk;
#if defined(UNTRUST)
	if( SXMEM_BACKEND_CORRUPT(pBackend) ){
		return 0;
	}
#endif
	if( pBackend->pMutexMethods ){
		SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
	}
	pChunk = MemBackendPoolAlloc(&(*pBackend), nByte);
	if( pBackend->pMutexMethods ){
		SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
	}
	return pChunk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x27a1c
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x27a1c
callq *0x20(%rax)
leal 0x8(%r14), %esi
cmpl $0x7ff7, %r14d          # imm = 0x7FF7
jbe 0x27a44
movq %rbx, %rdi
callq 0x2c2f8
testq %rax, %rax
je 0x27aa5
movq %rax, %r14
movl $0xdeadffff, (%rax)     # imm = 0xDEADFFFF
jmp 0x27ac6
pushq $0x8
popq %rax
pushq $0x3
popq %r15
cmpl %esi, %eax
jae 0x27a56
addl %eax, %eax
incl %r15d
jmp 0x27a4b
leal -0x3(%r15), %r12d
movq 0x40(%rbx,%r12,8), %r14
testq %r14, %r14
jne 0x27ab4
movq %rbx, %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x2c2f8
testq %rax, %rax
je 0x27aa5
pushq $0x1
popq %rdx
movl %r15d, %ecx
shll %cl, %edx
movq %rax, 0x40(%rbx,%r12,8)
movq %rax, %rcx
addq %rdx, %rcx
xorl %esi, %esi
leaq (%rsi,%rdx), %rdi
cmpq $0x7fff, %rdi           # imm = 0x7FFF
ja 0x27aaa
leaq (%rcx,%rsi), %r8
movq %r8, (%rax,%rsi)
movq %rdi, %rsi
jmp 0x27a8b
xorl %r14d, %r14d
jmp 0x27aca
andq $0x0, (%rax,%rsi)
movq 0x40(%rbx,%r12,8), %r14
movq (%r14), %rax
movq %rax, 0x40(%rbx,%r12,8)
orl $0xdead0000, %r12d      # imm = 0xDEAD0000
movl %r12d, (%r14)
addq $0x8, %r14
movq (%rbx), %rax
testq %rax, %rax
je 0x27ade
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x27ade
callq *0x30(%rax)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyZero
JX9_PRIVATE void SyZero(void *pSrc, sxu32 nSize)
{
	register unsigned char *zSrc = (unsigned char *)pSrc;
	unsigned char *zEnd;
#if defined(UNTRUST)
	if( zSrc == 0 || nSize <= 0 ){
		return ;
	}
#endif
	zEnd = &zSrc[nSize];
	for(;;){
		if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
		if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
		if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
		if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
addq %rdi, %rax
cmpq %rax, %rdi
jae 0x27b21
movb $0x0, (%rdi)
incq %rdi
cmpq %rax, %rdi
jae 0x27b21
movb $0x0, (%rdi)
incq %rdi
cmpq %rax, %rdi
jae 0x27b21
movb $0x0, (%rdi)
incq %rdi
cmpq %rax, %rdi
jae 0x27b21
movb $0x0, (%rdi)
incq %rdi
jmp 0x27af3
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendRelease
JX9_PRIVATE sxi32 SyMemBackendRelease(SyMemBackend *pBackend)
{
	sxi32 rc;
#if defined(UNTRUST)
	if( SXMEM_BACKEND_CORRUPT(pBackend) ){
		return SXERR_INVALID;
	}
#endif
	if( pBackend->pMutexMethods ){
		SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
	}
	rc = MemBackendRelease(&(*pBackend));
	if( pBackend->pMutexMethods ){
		SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
		SyMutexRelease(pBackend->pMutexMethods, pBackend->pMutex);
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x27b45
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x27b45
callq *0x20(%rax)
movq 0x10(%rbx), %r14
leaq 0x8(%rbx), %r12
movl 0x18(%rbx), %eax
testl %eax, %eax
je 0x27ba1
movq (%r14), %r15
movq 0x8(%rbx), %rax
movq %r14, %rdi
callq *0x10(%rax)
decl 0x18(%rbx)
je 0x27ba1
movq (%r15), %r14
movq 0x8(%rbx), %rax
movq %r15, %rdi
callq *0x10(%rax)
decl 0x18(%rbx)
je 0x27ba1
movq (%r14), %r15
movq 0x8(%rbx), %rax
movq %r14, %rdi
callq *0x10(%rax)
decl 0x18(%rbx)
je 0x27ba1
movq (%r15), %r14
movq 0x8(%rbx), %rax
movq %r15, %rdi
callq *0x10(%rax)
movl 0x18(%rbx), %eax
decl %eax
movl %eax, 0x18(%rbx)
jmp 0x27b50
movq (%r12), %rcx
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0x27bb4
movq 0x30(%rcx), %rdi
callq *%rax
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq (%rbx), %rax
testq %rax, %rax
je 0x27bef
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x27bef
callq *0x30(%rax)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x27bef
movq (%rbx), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x27bef
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendPoolFree
JX9_PRIVATE sxi32 SyMemBackendPoolFree(SyMemBackend *pBackend, void * pChunk)
{
	sxi32 rc;
#if defined(UNTRUST)
	if( SXMEM_BACKEND_CORRUPT(pBackend) || pChunk == 0 ){
		return SXERR_CORRUPT;
	}
#endif
	if( pBackend->pMutexMethods ){
		SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
	}
	rc = MemBackendPoolFree(&(*pBackend), pChunk);
	if( pBackend->pMutexMethods ){
		SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x27c19
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x27c19
callq *0x20(%rax)
movl -0x8(%r14), %eax
movl %eax, %ecx
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
cmpl $0xdead0000, %ecx       # imm = 0xDEAD0000
jne 0x27c44
addq $-0x8, %r14
cmpw $-0x1, %ax
jne 0x27c4a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d46e
jmp 0x27c5a
pushq $-0x18
popq %r14
jmp 0x27c5d
andl $0xf, %eax
movq 0x40(%rbx,%rax,8), %rcx
movq %rcx, (%r14)
movq %r14, 0x40(%rbx,%rax,8)
xorl %r14d, %r14d
movq (%rbx), %rax
testq %rax, %rax
je 0x27c71
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x27c71
callq *0x30(%rax)
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlite_close
int unqlite_close(unqlite *pDb)
{
	int rc;
	if( UNQLITE_DB_MISUSE(pDb) ){
		return UNQLITE_CORRUPT;
	}
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Acquire DB mutex */
	 SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
	 if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE && 
		 UNQLITE_THRD_DB_RELEASE(pDb) ){
			 return UNQLITE_ABORT; /* Another thread have released this instance */
	 }
#endif
	/* Release the database handle */
	rc = unqliteDbRelease(pDb);
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Leave DB mutex */
	 SyMutexLeave(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
	 /* Release DB mutex */
	 SyMutexRelease(sUnqlMPGlobal.pMutexMethods, pDb->pMutex) /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
#if defined(UNQLITE_ENABLE_THREADS)
	/* Enter the global mutex */
	 SyMutexEnter(sUnqlMPGlobal.pMutexMethods, sUnqlMPGlobal.pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel == UNQLITE_THREAD_LEVEL_SINGLE */
#endif
	/* Unlink from the list of active database handles */
	 MACRO_LD_REMOVE(sUnqlMPGlobal.pDB, pDb);
	sUnqlMPGlobal.nDB--;
#if defined(UNQLITE_ENABLE_THREADS)
	/* Leave the global mutex */
	 SyMutexLeave(sUnqlMPGlobal.pMutexMethods, sUnqlMPGlobal.pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel == UNQLITE_THREAD_LEVEL_SINGLE */
#endif
	/* Release the memory chunk allocated to this handle */
	SyMemBackendPoolFree(&sUnqlMPGlobal.sAllocator,pDb);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
pushq $-0x18
popq %r14
testq %rdi, %rdi
je 0x28083
movq %rdi, %rbx
cmpl $0xdb7c2712, 0x120(%rdi) # imm = 0xDB7C2712
jne 0x28083
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x27fa4
movq 0x5f7f7(%rip), %rax     # 0x87798
callq *0x20(%rax)
cmpl $0x2, 0x5f7fd(%rip)     # 0x877a8
jb 0x27fbd
cmpl $0xdb7c2712, 0x120(%rbx) # imm = 0xDB7C2712
jne 0x2807f
movq %rbx, %rdi
callq 0x2808b
movl %eax, %r14d
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x27ffc
movq 0x5f7bd(%rip), %rax     # 0x87798
callq *0x30(%rax)
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x27ffc
movq 0x5f7a7(%rip), %rax     # 0x87798
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x27ffc
callq *%rax
movq 0x5f79d(%rip), %rdi     # 0x877a0
testq %rdi, %rdi
je 0x28012
movq 0x5f789(%rip), %rax     # 0x87798
callq *0x20(%rax)
movq 0x5f7d7(%rip), %rax     # 0x877f0
cmpq %rbx, %rax
jne 0x2802c
movq 0x110(%rax), %rax
movq %rax, 0x5f7c4(%rip)     # 0x877f0
movq 0x110(%rbx), %rax
movq 0x118(%rbx), %rcx
testq %rcx, %rcx
je 0x28046
movq %rax, 0x110(%rcx)
testq %rax, %rax
je 0x28052
movq %rcx, 0x118(%rax)
decl 0x5f790(%rip)           # 0x877e8
movq 0x5f741(%rip), %rdi     # 0x877a0
testq %rdi, %rdi
je 0x2806e
movq 0x5f72d(%rip), %rax     # 0x87798
callq *0x30(%rax)
leaq 0x5f66b(%rip), %rdi     # 0x876e0
movq %rbx, %rsi
callq 0x27bf8
jmp 0x28083
pushq $-0xa
popq %r14
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlite_compile
int unqlite_compile(unqlite *pDb,const char *zJx9,int nByte,unqlite_vm **ppOut)
{
	jx9_vm *pVm;
	int rc;
	if( UNQLITE_DB_MISUSE(pDb) || ppOut == 0){
		return UNQLITE_CORRUPT;
	}
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Acquire DB mutex */
	 SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
	 if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE && 
		 UNQLITE_THRD_DB_RELEASE(pDb) ){
			 return UNQLITE_ABORT;
	 }
#endif
	 /* Compile the Jx9 script first */
	 rc = jx9_compile(pDb->sDB.pJx9,zJx9,nByte,&pVm);
	 if( rc == JX9_OK ){
		 /* Allocate a new unqlite VM instance */
		 rc = unqliteInitVm(pDb,pVm,ppOut);
		 if( rc != UNQLITE_OK ){
			 /* Release the Jx9 VM */
			 jx9_vm_release(pVm);
		 }
	 }
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Leave DB mutex */
	 SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $-0x18
popq %r15
testq %rdi, %rdi
je 0x28404
movq %rcx, %r14
testq %rcx, %rcx
je 0x28404
movq %rdi, %rbx
cmpl $0xdb7c2712, 0x120(%rdi) # imm = 0xDB7C2712
jne 0x28404
movl %edx, %r13d
movq %rsi, %r12
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x282f3
movq 0x5f4a8(%rip), %rax     # 0x87798
callq *0x20(%rax)
cmpl $0x2, 0x5f4ae(%rip)     # 0x877a8
jb 0x2830c
cmpl $0xdb7c2712, 0x120(%rbx) # imm = 0xDB7C2712
jne 0x283e4
movq 0xe0(%rbx), %rcx
testq %rcx, %rcx
je 0x283ee
cmpl $0xf874bcd7, 0x118(%rcx) # imm = 0xF874BCD7
jne 0x283ee
testq %r12, %r12
pushq $0x1
popq %rax
cmovel %eax, %r13d
leaq 0x3ebc9(%rip), %r15     # 0x66f06
cmovneq %r12, %r15
testl %r13d, %r13d
jns 0x28357
movq %r15, %rdi
movq %rcx, %r12
callq 0x28e24
movq %r12, %rcx
movl %eax, %r13d
movq %r15, -0x40(%rbp)
movl %r13d, -0x38(%rbp)
movq 0xf0(%rcx), %rdi
testq %rdi, %rdi
je 0x2837b
movq 0x5fd4e(%rip), %rax     # 0x880c0
movq %rcx, %r15
callq *0x20(%rax)
movq %r15, %rcx
cmpl $0x2, 0x5fd4e(%rip)     # 0x880d0
jb 0x28390
cmpl $0xf874bcd7, 0x118(%rcx) # imm = 0xF874BCD7
jne 0x283ea
leaq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rcx, %rdi
movq %rcx, %r12
xorl %ecx, %ecx
callq 0x3e1e8
movl %eax, %r15d
movq 0xf0(%r12), %rdi
testq %rdi, %rdi
je 0x283bf
movq 0x5fd04(%rip), %rax     # 0x880c0
callq *0x30(%rax)
testl %r15d, %r15d
jne 0x283ee
movq -0x30(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2841b
testl %eax, %eax
je 0x28416
movq -0x30(%rbp), %rdi
callq 0x2856a
pushq $-0x1
jmp 0x283ec
pushq $-0xa
popq %r15
jmp 0x28404
pushq $-0xa
popq %r15
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x28404
movq 0x5f397(%rip), %rax     # 0x87798
callq *0x30(%rax)
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x283ee
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteInitVm
static int unqliteInitVm(unqlite *pDb,jx9_vm *pJx9Vm,unqlite_vm **ppOut)
{
	unqlite_vm *pVm;

	*ppOut = 0;
	/* Allocate a new VM instance */
	pVm = (unqlite_vm *)SyMemBackendPoolAlloc(&pDb->sMem,sizeof(unqlite_vm));
	if( pVm == 0 ){
		return UNQLITE_NOMEM;
	}
	/* Zero the structure */
	SyZero(pVm,sizeof(unqlite_vm));
	/* Initialize */
	SyMemBackendInitFromParent(&pVm->sAlloc,&pDb->sMem);
	/* Allocate a new collection table */
	pVm->apCol = (unqlite_col **)SyMemBackendAlloc(&pVm->sAlloc,32 * sizeof(unqlite_col *)); 
	if( pVm->apCol == 0 ){
		goto fail;
	}
	pVm->iColSize = 32; /* Must be a power of two */
	/* Zero the table */
	SyZero((void *)pVm->apCol,pVm->iColSize * sizeof(unqlite_col *));
#if defined(UNQLITE_ENABLE_THREADS)
	if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE ){
		 /* Associate a recursive mutex with this instance */
		 pVm->pMutex = SyMutexNew(sUnqlMPGlobal.pMutexMethods, SXMUTEX_TYPE_RECURSIVE);
		 if( pVm->pMutex == 0 ){
			 goto fail;
		 }
	 }
#endif
	/* Link the VM to the list of active virtual machines */
	pVm->pJx9Vm = pJx9Vm;
	pVm->pDb = pDb;
	MACRO_LD_PUSH(pDb->pVms,pVm);
	pDb->iVm++;
	/* Register Jx9 functions */
	unqliteRegisterJx9Functions(pVm);
	/* Set the magic number */
	pVm->nMagic = JX9_VM_INIT; /* Same magic number as Jx9 */
	/* All done */
	*ppOut = pVm;
	return UNQLITE_OK;
fail:
	SyMemBackendRelease(&pVm->sAlloc);
	SyMemBackendPoolFree(&pDb->sMem,pVm);
	return UNQLITE_NOMEM;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
andq $0x0, (%rdx)
movl $0x100, %esi            # imm = 0x100
callq 0x279f7
pushq $-0x1
popq %r12
testq %rax, %rax
je 0x28558
movq %rax, %r14
movq %r13, -0x30(%rbp)
movq %rax, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x27aea
movq %r14, %r13
addq $0x8, %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2eaa1
movq %r13, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2ca19
movq %rax, 0xc8(%r14)
testq %rax, %rax
je 0x28545
movl $0x20, 0xdc(%r14)
movq %rax, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x27aea
cmpl $0x2, 0x5f2f9(%rip)     # 0x877a8
jb 0x284ca
movq 0x5f2e0(%rip), %rax     # 0x87798
pushq $0x2
popq %rdi
callq *0x10(%rax)
movq %rax, 0xc0(%r14)
testq %rax, %rax
je 0x28545
movq -0x30(%rbp), %rax
movq %rax, 0xe0(%r14)
movq %r15, (%r14)
movq 0x100(%r15), %rax
testq %rax, %rax
je 0x284f2
movq %rax, 0xe8(%r14)
movq %r14, 0xf0(%rax)
movq %r14, 0x100(%r15)
incl 0x108(%r15)
pushq $0x8
popq %r15
leaq 0x5bc25(%rip), %r12     # 0x84130
cmpq $0x1e8, %r15            # imm = 0x1E8
je 0x28532
movq 0xe0(%r14), %rdi
movq -0x8(%r15,%r12), %rsi
movq (%r15,%r12), %rdx
movq %r14, %rcx
callq 0x34fcf
addq $0x10, %r15
jmp 0x2850b
movl $0xea12cd72, 0xf8(%r14) # imm = 0xEA12CD72
movq %r14, (%rbx)
xorl %r12d, %r12d
jmp 0x28558
movq %r13, %rdi
callq 0x27b23
movq %r15, %rdi
movq %r14, %rsi
callq 0x27bf8
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlite_vm_config
int unqlite_vm_config(unqlite_vm *pVm,int iOp,...)
{
	va_list ap;
	int rc;
	if( UNQLITE_VM_MISUSE(pVm) ){
		return UNQLITE_CORRUPT;
	}
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Acquire VM mutex */
	 SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
	 if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE && 
		 UNQLITE_THRD_VM_RELEASE(pVm) ){
			 return UNQLITE_ABORT; /* Another thread have released this instance */
	 }
#endif
	 va_start(ap,iOp);
	 rc = unqliteVmConfig(pVm,iOp,ap);
	 va_end(ap);
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Leave DB mutex */
	 SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdx, -0xd0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x288b7
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
pushq $-0x18
popq %r15
testq %rdi, %rdi
je 0x28957
movq %rdi, %rbx
cmpl $0xdead2bad, 0xf8(%rdi) # imm = 0xDEAD2BAD
je 0x28957
movl %esi, %r14d
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x288f0
movq 0x5eeab(%rip), %rax     # 0x87798
callq *0x20(%rax)
cmpl $0x2, 0x5eeb1(%rip)     # 0x877a8
jb 0x2890b
cmpl $0xdead2bad, 0xf8(%rbx) # imm = 0xDEAD2BAD
jne 0x2890b
pushq $-0xa
popq %r15
jmp 0x28957
leaq -0xe0(%rbp), %rax
leaq -0x30(%rbp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0xe0(%rbx), %rdi
movl %r14d, %esi
callq 0x3c21c
movl %eax, %r15d
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x28957
movq 0x5ee44(%rip), %rax     # 0x87798
callq *0x30(%rax)
movl %r15d, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlite_vm_exec
int unqlite_vm_exec(unqlite_vm *pVm)
{
	int rc;
	if( UNQLITE_VM_MISUSE(pVm) ){
		return UNQLITE_CORRUPT;
	}
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Acquire VM mutex */
	 SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
	 if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE && 
		 UNQLITE_THRD_VM_RELEASE(pVm) ){
			 return UNQLITE_ABORT; /* Another thread have released this instance */
	 }
#endif
	/* Execute the Jx9 bytecode program */
	 rc = jx9VmByteCodeExec(pVm->pJx9Vm);
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Leave DB mutex */
	 SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
pushq $-0x18
popq %r14
testq %rdi, %rdi
je 0x28a26
movq %rdi, %rbx
cmpl $0xdead2bad, 0xf8(%rdi) # imm = 0xDEAD2BAD
je 0x28a26
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x289a5
movq 0x5edf6(%rip), %rax     # 0x87798
callq *0x20(%rax)
cmpl $0x2, 0x5edfc(%rip)     # 0x877a8
jb 0x289c0
cmpl $0xdead2bad, 0xf8(%rbx) # imm = 0xDEAD2BAD
jne 0x289c0
pushq $-0xa
popq %r14
jmp 0x28a26
movq 0xe0(%rbx), %rdi
movl 0x6e8(%rdi), %eax
cmpl $0xba851227, %eax       # imm = 0xBA851227
jne 0x28a04
movl $0xcdfe1dad, 0x6e8(%rdi) # imm = 0xCDFE1DAD
movq 0xf0(%rdi), %rax
movq 0x258(%rdi), %rdx
movq 0x8(%rax), %rsi
leaq 0x490(%rdi), %r8
pushq $-0x1
popq %rcx
callq 0x384e3
xorl %r14d, %r14d
jmp 0x28a10
cmpl $0xcdfe1dad, %eax       # imm = 0xCDFE1DAD
pushq $-0x4
popq %rax
cmovel %eax, %r14d
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x28a26
movq 0x5ed75(%rip), %rax     # 0x87798
callq *0x30(%rax)
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqlite_vm_reset
int unqlite_vm_reset(unqlite_vm *pVm)
{
	int rc;
	if( UNQLITE_VM_MISUSE(pVm) ){
		return UNQLITE_CORRUPT;
	}
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Acquire VM mutex */
	 SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
	 if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE && 
		 UNQLITE_THRD_VM_RELEASE(pVm) ){
			 return UNQLITE_ABORT; /* Another thread have released this instance */
	 }
#endif
	/* Reset the Jx9 VM */
	 rc = jx9VmReset(pVm->pJx9Vm);
#if defined(UNQLITE_ENABLE_THREADS)
	 /* Leave DB mutex */
	 SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
pushq $-0x18
popq %r14
testq %rdi, %rdi
je 0x28c4c
movq %rdi, %rbx
cmpl $0xdead2bad, 0xf8(%rdi) # imm = 0xDEAD2BAD
je 0x28c4c
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x28bd3
movq 0x5ebc8(%rip), %rax     # 0x87798
callq *0x20(%rax)
cmpl $0x2, 0x5ebce(%rip)     # 0x877a8
jb 0x28bee
cmpl $0xdead2bad, 0xf8(%rbx) # imm = 0xDEAD2BAD
jne 0x28bee
pushq $-0xa
popq %r14
jmp 0x28c4c
movq 0xe0(%rbx), %r14
movl 0x6e8(%r14), %eax
cmpl $0xcdfe1dad, %eax       # imm = 0xCDFE1DAD
je 0x28c0a
cmpl $0xba851227, %eax       # imm = 0xBA851227
jne 0x28c32
leaq 0x388(%r14), %rdi
callq 0x31b1e
leaq 0x490(%r14), %rdi
callq 0x296af
movl $0xba851227, 0x6e8(%r14) # imm = 0xBA851227
xorl %r14d, %r14d
jmp 0x28c36
pushq $-0x18
popq %r14
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x28c4c
movq 0x5eb4f(%rip), %rax     # 0x87798
callq *0x30(%rax)
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq