LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tjohnman[P]sfxr-sdl2/build/../src/main.cpp
// Function: ddkCalcFrame()
bool ddkCalcFrame()
{
	input->Update(); // (for keyboard input)

	if(input->KeyPressed(DIK_SPACE) || input->KeyPressed(DIK_RETURN)) // (keyboard input only for convenience, ok to remove)
	{
		if(!keydown)
		{
			PlaySample();
			keydown=true;
		}
	}
	else if(input->KeyPressed(DIK_Z))
	{
		Undo();
		keydown=true;
	}
	else
		keydown=false;

	DrawScreen();

	SDL_Delay(5);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x8560
movl $0x20, %edi
callq 0x8870
testb $0x1, %al
jne 0x8047
movl $0xd, %edi
callq 0x8870
testb $0x1, %al
jne 0x8047
jmp 0x805e
testb $0x1, 0xc66a(%rip)      # 0x146b8
jne 0x805c
callq 0x4740
movb $0x1, 0xc65c(%rip)      # 0x146b8
jmp 0x8085
movl $0x7a, %edi
callq 0x8870
testb $0x1, %al
jne 0x806e
jmp 0x807c
callq 0x38a0
movb $0x1, 0xc63e(%rip)      # 0x146b8
jmp 0x8083
movb $0x0, 0xc635(%rip)      # 0x146b8
jmp 0x8085
callq 0x5970
movl $0x5, %edi
callq 0x3240
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: tjohnman[P]sfxr-sdl2/build/../src/main.cpp
// Function: SDLAudioCallback(void*, unsigned char*, int)
static void SDLAudioCallback(void *userdata, Uint8 *stream, int len)
{
	if (playing_sample && !mute_stream)
	{
		unsigned int l = len/2;
		float* fbuf = new float[l];
		memset(fbuf, 0, sizeof(float));
		SynthSample(l, fbuf, NULL);
		while (l--)
		{
			float f = fbuf[l];
			if (f < -1.0) f = -1.0;
			if (f > 1.0) f = 1.0;
			((Sint16*)stream)[l] = (Sint16)(f * 32767);
		}
		delete[] fbuf;
	}
	else memset(stream, 0, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
testb $0x1, 0xb26a(%rip)      # 0x13544
je 0x83f1
testb $0x1, 0xc3c1(%rip)      # 0x146a8
jne 0x83f1
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x3190
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4760
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
je 0x83d8
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x5d8f(%rip), %xmm0     # 0xe108
ucomisd %xmm1, %xmm0
jbe 0x838c
movss 0x5cd1(%rip), %xmm0     # 0xe058
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5d3b(%rip), %xmm1     # 0xe0d8
ucomisd %xmm1, %xmm0
jbe 0x83b0
movss 0x5c5d(%rip), %xmm0     # 0xe008
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movss 0x5cff(%rip), %xmm1     # 0xe0bc
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
jmp 0x8343
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x83ef
movq -0x30(%rbp), %rdi
callq 0x3460
jmp 0x8400
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
xorl %esi, %esi
callq 0x3190
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: sdlupdate()
void sdlupdate ()
{
	mouse_px = mouse_x;
	mouse_py = mouse_y;
	Uint8 buttons = SDL_GetMouseState(&mouse_x, &mouse_y);
	bool mouse_left_p = mouse_left;
	bool mouse_right_p = mouse_right;
	bool mouse_middle_p = mouse_middle;
	mouse_left = buttons & SDL_BUTTON(1);
	mouse_right = buttons & SDL_BUTTON(3);
	mouse_middle = buttons & SDL_BUTTON(2);
	mouse_leftclick = mouse_left && !mouse_left_p;
	mouse_rightclick = mouse_right && !mouse_right_p;
	mouse_middleclick = mouse_middle && !mouse_middle_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0xbe4e(%rip), %eax      # 0x1470c
movl %eax, 0xbe50(%rip)      # 0x14714
movl 0xbe46(%rip), %eax      # 0x14710
movl %eax, 0xbe48(%rip)      # 0x14718
leaq 0xbe35(%rip), %rdi      # 0x1470c
leaq 0xbe32(%rip), %rsi      # 0x14710
callq 0x3550
movb %al, -0x1(%rbp)
movb 0xbe30(%rip), %al       # 0x1471c
andb $0x1, %al
movb %al, -0x2(%rbp)
movb 0xbe26(%rip), %al       # 0x1471d
andb $0x1, %al
movb %al, -0x3(%rbp)
movb 0xbe1c(%rip), %al       # 0x1471e
andb $0x1, %al
movb %al, -0x4(%rbp)
movzbl -0x1(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xbe00(%rip)       # 0x1471c
movzbl -0x1(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xbdec(%rip)       # 0x1471d
movzbl -0x1(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xbdd8(%rip)       # 0x1471e
xorl %eax, %eax
testb $0x1, 0xbdcd(%rip)      # 0x1471c
movb %al, -0x5(%rbp)
je 0x895c
movb -0x2(%rbp), %al
xorb $-0x1, %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movb %al, 0xbdb8(%rip)       # 0x1471f
xorl %eax, %eax
testb $0x1, 0xbdad(%rip)      # 0x1471d
movb %al, -0x6(%rbp)
je 0x897d
movb -0x3(%rbp), %al
xorb $-0x1, %al
movb %al, -0x6(%rbp)
movb -0x6(%rbp), %al
andb $0x1, %al
movb %al, 0xbd98(%rip)       # 0x14720
xorl %eax, %eax
testb $0x1, 0xbd8d(%rip)      # 0x1471e
movb %al, -0x7(%rbp)
je 0x899e
movb -0x4(%rbp), %al
xorb $-0x1, %al
movb %al, -0x7(%rbp)
movb -0x7(%rbp), %al
andb $0x1, %al
movb %al, 0xbd78(%rip)       # 0x14721
addq $0x10, %rsp
popq %rbp
retq
nop
// File: tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: ddkLock()
bool ddkLock ()
{
	if(SDL_MUSTLOCK(sdlscreen))
	{
		if(SDL_LockSurface(sdlscreen) < 0)
			return false;
	}
	ddkpitch = sdlscreen->pitch / (sdlscreen->format->BitsPerPixel == 32 ? 4 : 2);
	ddkscreen16 = (Uint16*)(sdlscreen->pixels);
	ddkscreen32 = (Uint32*)(sdlscreen->pixels);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xbd69(%rip), %rax      # 0x14728
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x89e2
movq 0xbd58(%rip), %rdi      # 0x14728
callq 0x34a0
cmpl $0x0, %eax
jge 0x89e0
movb $0x0, -0x1(%rbp)
jmp 0x8a3c
jmp 0x89e2
movq 0xbd3f(%rip), %rax      # 0x14728
movl 0x18(%rax), %eax
movq 0xbd35(%rip), %rcx      # 0x14728
movq 0x8(%rcx), %rcx
movzbl 0x10(%rcx), %esi
movl $0x2, %ecx
movl $0x4, %edx
cmpl $0x20, %esi
cmovel %edx, %ecx
cltd
idivl %ecx
movl %eax, 0xbcf4(%rip)      # 0x14708
movq 0xbd0d(%rip), %rax      # 0x14728
movq 0x20(%rax), %rax
movq %rax, 0xbcda(%rip)      # 0x14700
movq 0xbcfb(%rip), %rax      # 0x14728
movq 0x20(%rax), %rax
movq %rax, 0xbcc0(%rip)      # 0x146f8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: ddkSetMode(int, int, int, char const*)
void ddkSetMode (int width, int height, int fullscreen, const char *title)
{
	window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_SHOWN | (fullscreen ? SDL_WINDOW_FULLSCREEN : 0));
	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);
	SDL_SetWindowTitle(window, title);
	sdlscreen = SDL_GetWindowSurface(window);

	if(!sdlscreen) {
		std::cout << SDL_GetError() << std::endl;
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
movl -0xc(%rbp), %edx
xorl %r9d, %r9d
movl $0x1, %eax
cmpl $0x0, %edx
cmovnel %eax, %r9d
orl $0x4, %r9d
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
movl %edx, %esi
callq 0x3070
movq %rax, 0xbc67(%rip)      # 0x14730
movq 0xbc60(%rip), %rdi      # 0x14730
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3060
movq %rax, 0xbc52(%rip)      # 0x14738
movq 0xbc43(%rip), %rdi      # 0x14730
movq -0x18(%rbp), %rsi
callq 0x35b0
movq 0xbc33(%rip), %rdi      # 0x14730
callq 0x3480
movq %rax, 0xbc1f(%rip)      # 0x14728
cmpq $0x0, 0xbc17(%rip)      # 0x14728
jne 0x8b40
callq 0x3250
movq %rax, %rsi
movq 0xa4ae(%rip), %rdi      # 0x12fd0
callq 0x3330
movq %rax, %rdi
movq 0xa48f(%rip), %rsi      # 0x12fc0
callq 0x3390
movl $0x1, %edi
callq 0x3430
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: stoupper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string stoupper(const std::string& s)
{
	std::string result = s;
	std::string::iterator i = result.begin();
	std::string::iterator end = result.end();
	
	while(i != end)
	{
		*i = std::toupper((unsigned char)*i);
		++i;
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3140
movq -0x30(%rbp), %rdi
callq 0x32b0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x31b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa170
testb $0x1, %al
jne 0x8eb5
jmp 0x8ee2
leaq -0x20(%rbp), %rdi
callq 0xa1b0
movzbl (%rax), %edi
callq 0x3600
movb %al, -0x39(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa1b0
movb -0x39(%rbp), %cl
movb %cl, (%rax)
leaq -0x20(%rbp), %rdi
callq 0xa1d0
jmp 0x8ea2
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8ef5
movq -0x30(%rbp), %rdi
callq 0x31e0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: ioNew(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool ioNew(const std::string& filename)
{
    if(ioExists(filename))
        return false;
    
    FILE* file = fopen(filename.c_str(), "wb");
    if(file == NULL)
        return false;
    fclose(file);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f00
testb $0x1, %al
jne 0x8f4b
jmp 0x8f51
movb $0x0, -0x1(%rbp)
jmp 0x8f87
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, %rdi
leaq 0x51db(%rip), %rsi      # 0xe13f
callq 0x3410
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8f7a
movb $0x0, -0x1(%rbp)
jmp 0x8f87
movq -0x18(%rbp), %rdi
callq 0x3340
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: sdlinit()
void sdlinit ()
{
	SDL_Surface *icon;
	VERIFY(!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO));
	icon = SDL_LoadBMP("/usr/local/share/sfxr/images/sfxr.bmp");
	if (!icon)
		icon = SDL_LoadBMP("images/sfxr.bmp");
	if (icon)
		SDL_SetWindowIcon(window, icon);
	atexit(sdlquit);
	keys.clear();
	ddkInit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x30, %edi
callq 0x32d0
cmpl $0x0, %eax
je 0x99ff
leaq 0x4b07(%rip), %rdi      # 0xe4f5
movl $0x185, %esi            # imm = 0x185
leaq 0x4b0d(%rip), %rdx      # 0xe507
callq 0x8830
jmp 0x9a01
leaq 0x4b24(%rip), %rdi      # 0xe52c
leaq 0x472d(%rip), %rsi      # 0xe13c
callq 0x3130
movq %rax, %rdi
movl $0x1, %esi
callq 0x32f0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9a50
leaq 0x4b0f(%rip), %rdi      # 0xe542
leaq 0x4702(%rip), %rsi      # 0xe13c
callq 0x3130
movq %rax, %rdi
movl $0x1, %esi
callq 0x32f0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9a67
movq 0xacd2(%rip), %rdi      # 0x14730
movq -0x8(%rbp), %rsi
callq 0x3400
leaq -0xae(%rip), %rdi       # 0x99c0
callq 0xd2e0
leaq 0xac4e(%rip), %rdi      # 0x146c8
callq 0xa3a0
callq 0x80a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: loop()
void loop (void)
{
	SDL_Event e;
	while (true)
	{
		SDL_PollEvent(&e);
		switch (e.type)
		{
			case SDL_QUIT:
				exit(0);
	
			case SDL_KEYDOWN:
				keys[e.key.keysym.sym] = true;
	
			default: break;
		}
		sdlupdate();
		if (!ddkCalcFrame())
			return;
		SDL_UpdateWindowSurface(window);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x38(%rbp), %rdi
callq 0x31d0
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0x100, %eax            # imm = 0x100
je 0x9abc
jmp 0x9ab0
movl -0x3c(%rbp), %eax
subl $0x300, %eax            # imm = 0x300
je 0x9ac3
jmp 0x9ade
xorl %edi, %edi
callq 0x3430
leaq -0x38(%rbp), %rsi
addq $0x10, %rsi
addq $0x4, %rsi
leaq 0xabf2(%rip), %rdi      # 0x146c8
callq 0x9b80
movb $0x1, (%rax)
jmp 0x9ae0
callq 0x88b0
callq 0x8020
testb $0x1, %al
jne 0x9af4
addq $0x40, %rsp
popq %rbp
retq
movq 0xac35(%rip), %rdi      # 0x14730
callq 0x33f0
jmp 0x9a98
nopw %cs:(%rax,%rax)
// File: tjohnman[P]sfxr-sdl2/build/../src/tools.cpp
// Function: ClearScreen(unsigned int)
void ClearScreen(DWORD color)
{
	for(int y=0;y<480;y++)
	{
		int offset=y*ddkpitch;
		for(int x=0;x<640;x+=8)
		{
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x1e0, -0x8(%rbp)      # imm = 0x1E0
jge 0xcdcd
movl -0x8(%rbp), %eax
leaq 0x7a63(%rip), %rcx      # 0x14708
imull (%rcx), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x280, -0x10(%rbp)     # imm = 0x280
jge 0xcdbd
movl -0x4(%rbp), %edx
leaq 0x7a2f(%rip), %rax      # 0x146f8
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edx
leaq 0x7a11(%rip), %rax      # 0x146f8
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edx
leaq 0x79f3(%rip), %rax      # 0x146f8
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edx
leaq 0x79d5(%rip), %rax      # 0x146f8
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edx
leaq 0x79b7(%rip), %rax      # 0x146f8
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edx
leaq 0x7999(%rip), %rax      # 0x146f8
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edx
leaq 0x797b(%rip), %rax      # 0x146f8
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edx
leaq 0x795d(%rip), %rax      # 0x146f8
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x10(%rbp)
jmp 0xccb2
jmp 0xcdbf
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xcc8e
popq %rbp
retq
nop
// File: tjohnman[P]sfxr-sdl2/build/../src/tools.cpp
// Function: DrawBox(int, int, int, int, unsigned int)
void DrawBox(int sx, int sy, int w, int h, DWORD color)
{
	DrawBar(sx, sy, w, 1, color);
	DrawBar(sx, sy, 1, h, color);
	DrawBar(sx+w, sy, 1, h, color);
	DrawBar(sx, sy+h, w+1, 1, color);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x14(%rbp), %r8d
movl $0x1, %ecx
callq 0xcdd0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl $0x1, %edx
callq 0xcdd0
movl -0x4(%rbp), %edi
addl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl $0x1, %edx
callq 0xcdd0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
addl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
addl $0x1, %edx
movl -0x14(%rbp), %r8d
movl $0x1, %ecx
callq 0xcdd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tjohnman[P]sfxr-sdl2/build/../src/tools.cpp
// Function: DrawSprite(Spriteset&, int, int, int, unsigned int)
void DrawSprite(Spriteset& sprites, int sx, int sy, int i, DWORD color)
{
	for(int y=0;y<sprites.height;y++)
	{
		int offset=(sy+y)*ddkpitch+sx;
		int spoffset=y*sprites.pitch+i*sprites.width;
		if(color&0xFF000000)
			for(int x=0;x<sprites.width;x++)
			{
				DWORD p=sprites.data[spoffset++];
				if(p!=0x300030)
					ddkscreen32[offset+x]=p;
			}
		else
			for(int x=0;x<sprites.width;x++)
			{
				DWORD p=sprites.data[spoffset++];
				if(p!=0x300030)
					ddkscreen32[offset+x]=color;
			}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0xd148
movl -0x10(%rbp), %eax
addl -0x1c(%rbp), %eax
leaq 0x76bf(%rip), %rcx      # 0x14708
imull (%rcx), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x10(%rcx), %eax
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
andl $0xff000000, %eax       # imm = 0xFF000000
cmpl $0x0, %eax
je 0xd0d9
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xd0d7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x300030, -0x2c(%rbp)  # imm = 0x300030
je 0xd0ca
movl -0x2c(%rbp), %edx
leaq 0x763d(%rip), %rax      # 0x146f8
movq (%rax), %rax
movl -0x20(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xd0cc
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd081
jmp 0xd138
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xd136
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
cmpl $0x300030, -0x34(%rbp)  # imm = 0x300030
je 0xd129
movl -0x18(%rbp), %edx
leaq 0x75de(%rip), %rax      # 0x146f8
movq (%rax), %rax
movl -0x20(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xd12b
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xd0e0
jmp 0xd138
jmp 0xd13a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd02c
popq %rbp
retq
nopw (%rax,%rax)
// File: tjohnman[P]sfxr-sdl2/build/../src/tools.cpp
// Function: DrawText(Spriteset&, int, int, unsigned int, char const*, ...)
void DrawText(Spriteset& font, int sx, int sy, DWORD color, const char *string, ...)
{
	char string2[256];
	va_list args;

	va_start(args, string);
	vsprintf(string2, string, args);
	va_end(args);

	int len=strlen(string2);
	for(int i=0;i<len;i++)
		DrawSprite(font, sx+i*8, sy, string2[i]-' ', color);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
testb %al, %al
je 0xd197
movaps %xmm0, -0x1d0(%rbp)
movaps %xmm1, -0x1c0(%rbp)
movaps %xmm2, -0x1b0(%rbp)
movaps %xmm3, -0x1a0(%rbp)
movaps %xmm4, -0x190(%rbp)
movaps %xmm5, -0x180(%rbp)
movaps %xmm6, -0x170(%rbp)
movaps %xmm7, -0x160(%rbp)
movq %r9, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
leaq -0x140(%rbp), %rax
leaq -0x200(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x28, (%rax)
leaq -0x120(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x140(%rbp), %rdx
callq 0x3170
leaq -0x140(%rbp), %rax
leaq -0x120(%rbp), %rdi
callq 0x3150
movl %eax, -0x144(%rbp)
movl $0x0, -0x148(%rbp)
movl -0x148(%rbp), %eax
cmpl -0x144(%rbp), %eax
jge 0xd25f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x148(%rbp), %eax
shll $0x3, %eax
addl %eax, %esi
movl -0x10(%rbp), %edx
movslq -0x148(%rbp), %rax
movsbl -0x120(%rbp,%rax), %ecx
subl $0x20, %ecx
movl -0x14(%rbp), %r8d
callq 0xd010
movl -0x148(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x148(%rbp)
jmp 0xd210
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
nopl (%rax,%rax)
// File: sile[P]unf/src/unf/unf-test.cc
// Function: nfd_test(UNF::Normalizer&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
bool nfd_test(UNF::Normalizer& norm, const std::vector<std::string>& ary) {
  return 
    NF_TEST(norm.nfd, ary[2], ary[0]) &&
    NF_TEST(norm.nfd, ary[2], ary[1]) &&
    NF_TEST(norm.nfd, ary[2], ary[2]) &&
    NF_TEST(norm.nfd, ary[4], ary[3]) &&
    NF_TEST(norm.nfd, ary[4], ary[4]);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x3120
movq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x57(%rsp)
jne 0x2588
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x3120
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x57(%rsp)
jne 0x2588
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x3120
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x57(%rsp)
jne 0x2588
movq 0x58(%rsp), %rdi
movl $0x4, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
movl $0x3, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3120
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x57(%rsp)
jne 0x2588
movq 0x58(%rsp), %rdi
movl $0x4, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
movl $0x4, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x3120
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
cmpl $0x0, %eax
sete %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sile[P]unf/src/unf/unf-test.cc
// Function: nfkc_test(UNF::Normalizer&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
bool nfkc_test(UNF::Normalizer& norm, const std::vector<std::string>& ary) {
  return 
    NF_TEST(norm.nfkc, ary[3], ary[0]) &&
    NF_TEST(norm.nfkc, ary[3], ary[1]) &&
    NF_TEST(norm.nfkc, ary[3], ary[2]) &&
    NF_TEST(norm.nfkc, ary[3], ary[3]) &&
    NF_TEST(norm.nfkc, ary[3], ary[4]);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movl $0x3, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x31b0
movq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x57(%rsp)
jne 0x2be8
movq 0x58(%rsp), %rdi
movl $0x3, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x31b0
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x57(%rsp)
jne 0x2be8
movq 0x58(%rsp), %rdi
movl $0x3, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x31b0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x57(%rsp)
jne 0x2be8
movq 0x58(%rsp), %rdi
movl $0x3, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
movl $0x3, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x31b0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x57(%rsp)
jne 0x2be8
movq 0x58(%rsp), %rdi
movl $0x3, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
movl $0x4, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x31b0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
cmpl $0x0, %eax
sete %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sile[P]unf/src/unf/unf-test.cc
// Function: nf_test(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, UNF::Normalizer&, int)
bool nf_test(const std::vector<std::string>& ary, UNF::Normalizer& norm, int entry_id) {
  static const UNF::Normalizer::Form forms[] = {UNF::Normalizer::FORM_NFD, UNF::Normalizer::FORM_NFC,
						UNF::Normalizer::FORM_NFKD,UNF::Normalizer::FORM_NFKC};
  static const TEST_FN_T test_fn[] = {nfd_test, nfc_test, nfkd_test, nfkc_test};
  static const char* form_names[5] = {"NFD ", "NFC ", "NFKD", "NFKC"};

  for(int formid=0; formid < 4; formid++)
    if(test_fn[formid](norm, ary)==false) {
      std::cerr << "Failed(" << entry_id << "): " << form_names[formid] << std::endl;
      for(unsigned i=0; i < ary.size(); i++) 
	std::cerr << " " << ary[i] << "\t -> " << norm.normalize(ary[i].c_str(), forms[formid]) << std::endl;
      return false;
    }
  return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
cmpl $0x4, 0x28(%rsp)
jge 0x2d9a
movslq 0x28(%rsp), %rcx
leaq 0x6914f(%rip), %rax     # 0x6bd80
movq (%rax,%rcx,8), %rax
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq *%rax
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2d88
movq 0x69392(%rip), %rdi     # 0x6bfe8
leaq 0x65ab6(%rip), %rsi     # 0x68713
callq 0x2150
movq %rax, %rdi
movl 0x2c(%rsp), %esi
callq 0x2220
movq %rax, %rdi
leaq 0x65aa3(%rip), %rsi     # 0x6871b
callq 0x2150
movq %rax, %rdi
movslq 0x28(%rsp), %rcx
leaq 0x694a4(%rip), %rax     # 0x6c130
movq (%rax,%rcx,8), %rsi
callq 0x2150
movq %rax, %rdi
movq 0x69319(%rip), %rsi     # 0x6bfb8
callq 0x2170
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x31e0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x2d81
movq 0x69311(%rip), %rdi     # 0x6bfe8
leaq 0x65a69(%rip), %rsi     # 0x68747
callq 0x2150
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x3100
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x2130
movq %rax, %rdi
leaq 0x65a12(%rip), %rsi     # 0x6871f
callq 0x2150
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x3100
movq %rax, %rdi
callq 0x2080
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movslq 0x28(%rsp), %rcx
leaq 0x42d3(%rip), %rax      # 0x7020
movl (%rax,%rcx,4), %edx
callq 0x3200
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x2150
movq %rax, %rdi
movq 0x6924c(%rip), %rsi     # 0x6bfb8
callq 0x2170
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2cac
movb $0x0, 0x47(%rsp)
jmp 0x2d9f
jmp 0x2d8a
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x2c1a
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::normalize(char const*, UNF::Normalizer::Form)
const char* normalize(const char* src, Form form) {
      switch(form) {
      case FORM_NFD:  return nfd(src);
      case FORM_NFC:  return nfc(src);
      case FORM_NFKD: return nfkd(src);
      case FORM_NFKC: return nfkc(src);
      default:        return src;
      }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x10(%rsp)
subq $0x3, %rax
ja 0x3298
movq 0x10(%rsp), %rax
leaq 0x3dcd(%rip), %rcx      # 0x7004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x3120
movq %rax, 0x30(%rsp)
jmp 0x32a2
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x3180
movq %rax, 0x30(%rsp)
jmp 0x32a2
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x3150
movq %rax, 0x30(%rsp)
jmp 0x32a2
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x31b0
movq %rax, 0x30(%rsp)
jmp 0x32a2
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::decompose(char const*, UNF::Trie::NormalizationForm const&)
const char* decompose(const char* src, const Trie::NormalizationForm& nf) {
      const char* beg = next_invalid_char(src, nf);
      if(*beg=='\0')
	return src;
      
      buffer.assign(src, beg);
      do {
	const char* end = next_valid_starter(beg, nf);
	decompose_one(beg, end, nf, buffer);
	beg = next_invalid_char(end, nf);
	buffer.append(end, beg);
      } while(*beg!='\0');
      
      return buffer.c_str();      
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x3750
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x369c
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3744
movq (%rsp), %rdi
addq $0x90, %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x3840
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x38a0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rdi, %r8
addq $0x90, %r8
callq 0x3940
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x3750
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x90, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x3a00
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x36b6
movq (%rsp), %rdi
addq $0x90, %rdi
callq 0x2080
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::next_invalid_char(char const*, UNF::Trie::NormalizationForm const&) const
const char* next_invalid_char(const char* src, const Trie::NormalizationForm& nf) const {
      int last_canonical_class = 0;
      const char* cur = Util::nearest_utf8_char_start_point(src);
      const char* starter = cur;
      
      for(; *cur != '\0'; cur = Util::nearest_utf8_char_start_point(cur+1)) {
	int canonical_class = ccc.get_class(cur);
	if(last_canonical_class > canonical_class && canonical_class != 0)
	  return starter;

	if(nf.quick_check(cur)==false)
	  return starter;

	if(canonical_class==0)
	  starter=cur;

	last_canonical_class = canonical_class;
      }
      return cur;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3a60
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3827
movq (%rsp), %rdi
addq $0x78, %rdi
movq 0x18(%rsp), %rsi
callq 0x3aa0
movl %eax, 0xc(%rsp)
movl 0x24(%rsp), %eax
cmpl 0xc(%rsp), %eax
jle 0x37d1
cmpl $0x0, 0xc(%rsp)
je 0x37d1
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x3831
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3ad0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x37f6
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x3831
cmpl $0x0, 0xc(%rsp)
jne 0x3807
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
callq 0x3a60
movq %rax, 0x18(%rsp)
jmp 0x378d
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::next_valid_starter(char const*, UNF::Trie::NormalizationForm const&) const
const char* next_valid_starter(const char* src, const Trie::NormalizationForm& nf) const {
      const char* cur = Util::nearest_utf8_char_start_point(src+1);
      while(ccc.get_class(cur)!=0 || nf.quick_check(cur)==false)
	cur = Util::nearest_utf8_char_start_point(cur+1);
      return cur;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
addq $0x1, %rdi
callq 0x3a60
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
addq $0x78, %rdi
movq 0x18(%rsp), %rsi
callq 0x3aa0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jne 0x390e
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3ad0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3918
jmp 0x392d
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
callq 0x3a60
movq %rax, 0x18(%rsp)
jmp 0x38d0
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::decompose_one(char const*, char const*, UNF::Trie::NormalizationForm const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void decompose_one(const char* beg, const char* end, const Trie::NormalizationForm& nf, std::string& buf) {
      unsigned last = buf.size();
      nf.decompose(Trie::RangeCharStream(beg,end), buf);
      char* bufbeg = const_cast<char*>(buf.data());
      canonical_combining_class_ordering(bufbeg+last, bufbeg+buf.size());
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x20f0
movl %eax, 0x3c(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x3f10
movq (%rsp), %rdi
movq 0x40(%rsp), %rcx
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x3d70
movq 0x40(%rsp), %rdi
callq 0x2180
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x3c(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x20f0
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq %rax, %rdx
callq 0x3f40
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: sile[P]unf/src/unf/trie/searcher.hh
// Function: UNF::Trie::Searcher::find_value(char const*, int) const
unsigned find_value(const char* key, int default_value) const {
	unsigned node_index=root;
	for(CharStream in(key);; in.read()) {
	  node_index = nodes[node_index].jump(in.peek());
	  if(nodes[node_index].check_char()==in.peek()) {
	    unsigned terminal_index = nodes[node_index].jump('\0'); 
	    if(nodes[terminal_index].check_char()=='\0') {
	      return nodes[terminal_index].value();
            }
	  } else
	    return default_value;
	}
      }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3c60
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x28(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3cb0
movq (%rsp), %rdi
movzbl %al, %esi
callq 0x3c80
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x28(%rsp)
movq (%rax), %rdi
movl 0x28(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x3cc0
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3cb0
movb %al, %cl
movl 0xc(%rsp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x3c35
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0x28(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x3c80
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1c(%rsp)
movq (%rax), %rdi
movl 0x1c(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x3cc0
cmpl $0x0, %eax
jne 0x3c33
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0x1c(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x3cd0
movl %eax, 0x44(%rsp)
jmp 0x3c50
jmp 0x3c3f
movl 0x2c(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x3c50
jmp 0x3c41
leaq 0x20(%rsp), %rdi
callq 0x3ce0
jmp 0x3b72
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: sile[P]unf/src/unf/trie/searcher.hh
// Function: UNF::Trie::NormalizationForm::decompose(UNF::Trie::RangeCharStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
void decompose(RangeCharStream in, std::string& buffer) const {
      loop_head:
	const char* beg = in.cur();

	for(unsigned node_index=root;;) {
	  node_index = nodes[node_index].jump(in.read());
	  if(nodes[node_index].check_char()==in.prev()) {
	    unsigned terminal_index = nodes[node_index].jump('\0');
	    if(nodes[terminal_index].check_char()=='\0') {
              word_append(buffer, value, nodes[terminal_index].value());
	      beg = in.cur();
	      break;
	    }
	  } else {
	    Util::eat_until_utf8_char_start_point(in);
	    buffer.append(beg, in.cur());
	    break;
	  }
	}  

	if(in.eos()==false)
	  goto loop_head;
      }

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x3fb0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x40(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x3c(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl 0x3c(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x3fc0
movq 0x20(%rsp), %rdi
movzbl %al, %esi
callq 0x3c80
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x3c(%rsp)
movq (%rax), %rdi
movl 0x3c(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x3cc0
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x4010
movb %al, %cl
movl 0x2c(%rsp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x3ea8
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movl 0x3c(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x3c80
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x38(%rsp)
movq (%rax), %rdi
movl 0x38(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x3cc0
cmpl $0x0, %eax
jne 0x3ea6
movq 0x30(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rdi
movl 0x38(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x3cd0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl %eax, %edx
callq 0x4030
leaq 0x58(%rsp), %rdi
callq 0x3fb0
movq %rax, 0x40(%rsp)
jmp 0x3ee7
jmp 0x3ee2
leaq 0x58(%rsp), %rdi
callq 0x4070
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x3fb0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x3a00
jmp 0x3ee7
jmp 0x3db0
leaq 0x58(%rsp), %rdi
callq 0x40a0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3f00
jmp 0x3d92
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: sile[P]unf/src/unf/trie/searcher.hh
// Function: UNF::Trie::CanonicalCombiningClass::bubble_sort(char*, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int, unsigned int) const
void bubble_sort(char* str, std::vector<unsigned char>& canonical_classes, unsigned beg, unsigned end) const {
	for(unsigned limit=beg, next=end; limit != next;) {
	  limit = next;
	  for(unsigned i=beg+1; i < limit; i++)
	    if(canonical_classes[i-1] > canonical_classes[i]) {
	      std::swap(canonical_classes[i-1], canonical_classes[i]);
	      std::swap(str[i-1], str[i]);
	      next = i;
	    }
	}
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
je 0x522b
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x5226
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5100
movzbl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %esi
callq 0x5100
movq %rax, %rcx
movl 0x8(%rsp), %eax
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jle 0x5214
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5100
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %esi
callq 0x5100
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x5260
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
addq %rax, %rdi
movq 0x28(%rsp), %rsi
movl 0xc(%rsp), %eax
addq %rax, %rsi
callq 0x5290
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x5216
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x516d
jmp 0x514c
addq $0x38, %rsp
retq
// File: sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::compose(char const*, UNF::Trie::NormalizationForm const&, UNF::Trie::NormalizationForm const&)
const char* compose(const char* src, const Trie::NormalizationForm& nf, const Trie::NormalizationForm& nf_decomp) {
      const char* beg = next_invalid_char(src, nf);
      if(*beg=='\0')
	return src;
      
      buffer.assign(src, beg);
      while(*beg!='\0') {
	const char* end = next_valid_starter(beg, nf);
	buffer2.clear();
	decompose_one(beg, end, nf_decomp, buffer2);
	end = compose_one(buffer2.c_str(), end, buffer);
	beg = next_invalid_char(end, nf);
	buffer.append(end, beg);
      }

      return buffer.c_str();      
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x3750
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5312
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x540c
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x3840
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x53f6
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x38a0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0xb0, %rdi
callq 0x2190
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %rdi, %r8
addq $0xb0, %r8
callq 0x3940
movq 0x8(%rsp), %rdi
addq $0xb0, %rdi
callq 0x2080
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rdx
movq %rdi, %rcx
addq $0x90, %rcx
callq 0x5420
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x3750
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x90, %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x3a00
jmp 0x532d
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
callq 0x2080
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::compose_one(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
const char* compose_one(const char* starter, const char* rest_starter, std::string& buf) {
      Trie::CharStreamForComposition in(starter, rest_starter, canonical_classes, buffer3);
      while(in.within_first())
	nf_c.compose(in, buf);
      return in.cur();
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %r8
movq %r8, (%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r8, %rcx
addq $0xf0, %rcx
addq $0xd0, %r8
leaq 0x8(%rsp), %rdi
callq 0x54a0
leaq 0x8(%rsp), %rdi
callq 0x5500
testb $0x1, %al
jne 0x5476
jmp 0x548f
movq (%rsp), %rdi
addq $0x30, %rdi
movq 0x48(%rsp), %rdx
leaq 0x8(%rsp), %rsi
callq 0x5520
jmp 0x5466
leaq 0x8(%rsp), %rdi
callq 0x57c0
addq $0x68, %rsp
retq
nop
// File: sile[P]unf/src/unf/trie/char_stream.hh
// Function: UNF::Trie::CharStreamForComposition::next_combining_char(unsigned char, char const*)
bool next_combining_char(unsigned char prev_class, const char* ppp) {
	while(Util::is_utf8_char_start_byte(peek()) == false)
	  read();
	
	unsigned char mid_class = get_prev_canonical_class();
	unsigned char cur_class = get_canonical_class();
	
	if(prev_class==0 && mid_class==0 && cur_class!=0)
	  return false;

	if(prev_class < cur_class && mid_class < cur_class) {
	  skipped.append(ppp, cur());
	  return true;
	} else {
	  if(cur_class != 0) {
	    read();
	    return next_combining_char(prev_class,ppp);
	  }
	  return false;
	}
      }

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x38(%rsp)
movb %al, 0x37(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x58a0
movsbl %al, %edi
callq 0x3b00
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5a87
movq 0x18(%rsp), %rdi
callq 0x5970
jmp 0x5a5f
movq 0x18(%rsp), %rdi
callq 0x5e10
movq 0x18(%rsp), %rdi
movb %al, 0x27(%rsp)
callq 0x58f0
movb %al, 0x26(%rsp)
movzbl 0x37(%rsp), %eax
cmpl $0x0, %eax
jne 0x5acb
movzbl 0x27(%rsp), %eax
cmpl $0x0, %eax
jne 0x5acb
movzbl 0x26(%rsp), %eax
cmpl $0x0, %eax
je 0x5acb
movb $0x0, 0x47(%rsp)
jmp 0x5b54
movzbl 0x37(%rsp), %eax
movzbl 0x26(%rsp), %ecx
cmpl %ecx, %eax
jge 0x5b1d
movzbl 0x27(%rsp), %eax
movzbl 0x26(%rsp), %ecx
cmpl %ecx, %eax
jge 0x5b1d
movq 0x18(%rsp), %rdi
movq 0x28(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x57c0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x3a00
movb $0x1, 0x47(%rsp)
jmp 0x5b54
movzbl 0x26(%rsp), %eax
cmpl $0x0, %eax
je 0x5b4f
movq 0x18(%rsp), %rdi
callq 0x5970
movq 0x18(%rsp), %rdi
movb 0x37(%rsp), %al
movq 0x28(%rsp), %rdx
movzbl %al, %esi
callq 0x5a40
andb $0x1, %al
movb %al, 0x47(%rsp)
jmp 0x5b54
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: sile[P]unf/src/unf/trie/char_stream.hh
// Function: UNF::Trie::CompoundCharStream::setCur(char const*)
void setCur(const char* p) { 
	if(beg1 <= p && p <= cur1) {
	  cur1=p;
	  cur2=beg2;
	} else {
	  cur2=p;
	}
      }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq (%rax), %rax
cmpq -0x10(%rsp), %rax
ja 0x5c46
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
cmpq 0x10(%rcx), %rax
ja 0x5c46
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x18(%rax)
jmp 0x5c54
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
nop