name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
glfwPlatformCreateTls | GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls)
{
assert(tls->posix.allocated == GLFW_FALSE);
if (pthread_key_create(&tls->posix.key, NULL) != 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"POSIX: Failed to create context TLS");
return GLFW_FALSE;
}
tls->posix.allocated = GLFW_TRUE;
return GLFW_TRUE;
} | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
jne 0x2aeae
movq %rdi, %r14
addq $0x4, %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x7890
testl %eax, %eax
je 0x2ae9a
leaq 0x36332(%rip), %rsi # 0x611be
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1eed8
jmp 0x2aea4
movl $0x1, (%r14)
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3624b(%rip), %rdi # 0x61100
leaq 0x36267(%rip), %rsi # 0x61123
leaq 0x362cf(%rip), %rcx # 0x61192
pushq $0x2a
popq %rdx
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/posix_thread.c |
glfwPlatformCreateMutex | GLFWbool _glfwPlatformCreateMutex(_GLFWmutex* mutex)
{
assert(mutex->posix.allocated == GLFW_FALSE);
if (pthread_mutex_init(&mutex->posix.handle, NULL) != 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR, "POSIX: Failed to create mutex");
return GLFW_FALSE;
}
return mutex->posix.allocated = GLFW_TRUE;
} | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
jne 0x2af7e
movq %rdi, %r14
addq $0x8, %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x77a0
testl %eax, %eax
je 0x2af6a
leaq 0x36350(%rip), %rsi # 0x612ac
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1eed8
jmp 0x2af74
movl $0x1, (%r14)
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x362d2(%rip), %rdi # 0x61257
leaq 0x36197(%rip), %rsi # 0x61123
leaq 0x362e9(%rip), %rcx # 0x6127c
pushq $0x4c
popq %rdx
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/posix_thread.c |
glfwInitGLX | GLFWbool _glfwInitGLX(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_GLX_LIBRARY)
_GLFW_GLX_LIBRARY,
#elif defined(__CYGWIN__)
"libGL-1.so",
#elif defined(__OpenBSD__) || defined(__NetBSD__)
"libGL.so",
#else
"libGL.so.1",
"libGL.so",
#endif
NULL
};
if (_glfw.glx.handle)
return GLFW_TRUE;
for (i = 0; sonames[i]; i++)
{
_glfw.glx.handle = _glfw_dlopen(sonames[i]);
if (_glfw.glx.handle)
break;
}
if (!_glfw.glx.handle)
{
_glfwInputError(GLFW_API_UNAVAILABLE, "GLX: Failed to load GLX");
return GLFW_FALSE;
}
_glfw.glx.GetFBConfigs =
_glfw_dlsym(_glfw.glx.handle, "glXGetFBConfigs");
_glfw.glx.GetFBConfigAttrib =
_glfw_dlsym(_glfw.glx.handle, "glXGetFBConfigAttrib");
_glfw.glx.GetClientString =
_glfw_dlsym(_glfw.glx.handle, "glXGetClientString");
_glfw.glx.QueryExtension =
_glfw_dlsym(_glfw.glx.handle, "glXQueryExtension");
_glfw.glx.QueryVersion =
_glfw_dlsym(_glfw.glx.handle, "glXQueryVersion");
_glfw.glx.DestroyContext =
_glfw_dlsym(_glfw.glx.handle, "glXDestroyContext");
_glfw.glx.MakeCurrent =
_glfw_dlsym(_glfw.glx.handle, "glXMakeCurrent");
_glfw.glx.SwapBuffers =
_glfw_dlsym(_glfw.glx.handle, "glXSwapBuffers");
_glfw.glx.QueryExtensionsString =
_glfw_dlsym(_glfw.glx.handle, "glXQueryExtensionsString");
_glfw.glx.CreateNewContext =
_glfw_dlsym(_glfw.glx.handle, "glXCreateNewContext");
_glfw.glx.CreateWindow =
_glfw_dlsym(_glfw.glx.handle, "glXCreateWindow");
_glfw.glx.DestroyWindow =
_glfw_dlsym(_glfw.glx.handle, "glXDestroyWindow");
_glfw.glx.GetVisualFromFBConfig =
_glfw_dlsym(_glfw.glx.handle, "glXGetVisualFromFBConfig");
if (!_glfw.glx.GetFBConfigs ||
!_glfw.glx.GetFBConfigAttrib ||
!_glfw.glx.GetClientString ||
!_glfw.glx.QueryExtension ||
!_glfw.glx.QueryVersion ||
!_glfw.glx.DestroyContext ||
!_glfw.glx.MakeCurrent ||
!_glfw.glx.SwapBuffers ||
!_glfw.glx.QueryExtensionsString ||
!_glfw.glx.CreateNewContext ||
!_glfw.glx.CreateWindow ||
!_glfw.glx.DestroyWindow ||
!_glfw.glx.GetVisualFromFBConfig)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"GLX: Failed to load required entry points");
return GLFW_FALSE;
}
// NOTE: Unlike GLX 1.3 entry points these are not required to be present
_glfw.glx.GetProcAddress = (PFNGLXGETPROCADDRESSPROC)
_glfw_dlsym(_glfw.glx.handle, "glXGetProcAddress");
_glfw.glx.GetProcAddressARB = (PFNGLXGETPROCADDRESSPROC)
_glfw_dlsym(_glfw.glx.handle, "glXGetProcAddressARB");
if (!glXQueryExtension(_glfw.x11.display,
&_glfw.glx.errorBase,
&_glfw.glx.eventBase))
{
_glfwInputError(GLFW_API_UNAVAILABLE, "GLX: GLX extension not found");
return GLFW_FALSE;
}
if (!glXQueryVersion(_glfw.x11.display, &_glfw.glx.major, &_glfw.glx.minor))
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"GLX: Failed to query GLX version");
return GLFW_FALSE;
}
if (_glfw.glx.major == 1 && _glfw.glx.minor < 3)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"GLX: GLX version 1.3 is required");
return GLFW_FALSE;
}
if (extensionSupportedGLX("GLX_EXT_swap_control"))
{
_glfw.glx.SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)
getProcAddressGLX("glXSwapIntervalEXT");
if (_glfw.glx.SwapIntervalEXT)
_glfw.glx.EXT_swap_control = GLFW_TRUE;
}
if (extensionSupportedGLX("GLX_SGI_swap_control"))
{
_glfw.glx.SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)
getProcAddressGLX("glXSwapIntervalSGI");
if (_glfw.glx.SwapIntervalSGI)
_glfw.glx.SGI_swap_control = GLFW_TRUE;
}
if (extensionSupportedGLX("GLX_MESA_swap_control"))
{
_glfw.glx.SwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)
getProcAddressGLX("glXSwapIntervalMESA");
if (_glfw.glx.SwapIntervalMESA)
_glfw.glx.MESA_swap_control = GLFW_TRUE;
}
if (extensionSupportedGLX("GLX_ARB_multisample"))
_glfw.glx.ARB_multisample = GLFW_TRUE;
if (extensionSupportedGLX("GLX_ARB_framebuffer_sRGB"))
_glfw.glx.ARB_framebuffer_sRGB = GLFW_TRUE;
if (extensionSupportedGLX("GLX_EXT_framebuffer_sRGB"))
_glfw.glx.EXT_framebuffer_sRGB = GLFW_TRUE;
if (extensionSupportedGLX("GLX_ARB_create_context"))
{
_glfw.glx.CreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)
getProcAddressGLX("glXCreateContextAttribsARB");
if (_glfw.glx.CreateContextAttribsARB)
_glfw.glx.ARB_create_context = GLFW_TRUE;
}
if (extensionSupportedGLX("GLX_ARB_create_context_robustness"))
_glfw.glx.ARB_create_context_robustness = GLFW_TRUE;
if (extensionSupportedGLX("GLX_ARB_create_context_profile"))
_glfw.glx.ARB_create_context_profile = GLFW_TRUE;
if (extensionSupportedGLX("GLX_EXT_create_context_es2_profile"))
_glfw.glx.EXT_create_context_es2_profile = GLFW_TRUE;
if (extensionSupportedGLX("GLX_ARB_create_context_no_error"))
_glfw.glx.ARB_create_context_no_error = GLFW_TRUE;
if (extensionSupportedGLX("GLX_ARB_context_flush_control"))
_glfw.glx.ARB_context_flush_control = GLFW_TRUE;
return GLFW_TRUE;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x45d91(%rip), %r14 # 0x70db8
cmpq $0x0, 0x215f0(%r14)
je 0x2b039
pushq $0x1
popq %rbx
jmp 0x2b31e
xorl %r15d, %r15d
leaq 0x3dcdd(%rip), %r12 # 0x68d20
pushq $0x1
popq %rbx
cmpq $0x10, %r15
je 0x2b2f9
movq (%r15,%r12), %rdi
movl %ebx, %esi
callq 0x76d0
movq %rax, 0x215f0(%r14)
addq $0x8, %r15
testq %rax, %rax
je 0x2b046
leaq 0x362fe(%rip), %rsi # 0x61370
movq %rax, %rdi
callq 0x7520
movq %rax, 0x215f8(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x362f1(%rip), %rsi # 0x61380
callq 0x7520
movq %rax, 0x21600(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x362ec(%rip), %rsi # 0x61395
callq 0x7520
movq %rax, 0x21608(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x362e5(%rip), %rsi # 0x613a8
callq 0x7520
movq %rax, 0x21610(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x362dd(%rip), %rsi # 0x613ba
callq 0x7520
movq %rax, 0x21618(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x362d3(%rip), %rsi # 0x613ca
callq 0x7520
movq %rax, 0x21620(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x362cb(%rip), %rsi # 0x613dc
callq 0x7520
movq %rax, 0x21628(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x362c0(%rip), %rsi # 0x613eb
callq 0x7520
movq %rax, 0x21630(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x362b5(%rip), %rsi # 0x613fa
callq 0x7520
movq %rax, 0x21638(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x362b4(%rip), %rsi # 0x61413
callq 0x7520
movq %rax, 0x21640(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x362ae(%rip), %rsi # 0x61427
callq 0x7520
movq %rax, 0x21650(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x362a4(%rip), %rsi # 0x61437
callq 0x7520
movq %rax, 0x21658(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x3629b(%rip), %rsi # 0x61448
callq 0x7520
movq %rax, 0x21648(%r14)
movdqu 0x215f8(%r14), %xmm3
movdqu 0x21608(%r14), %xmm4
movdqu 0x21618(%r14), %xmm5
movdqu 0x21628(%r14), %xmm6
movdqu 0x21638(%r14), %xmm0
movdqu 0x21650(%r14), %xmm1
testq %rax, %rax
setne %al
pxor %xmm2, %xmm2
pcmpeqd %xmm2, %xmm6
pshufd $0xb1, %xmm6, %xmm7 # xmm7 = xmm6[1,0,3,2]
pand %xmm6, %xmm7
pcmpeqd %xmm2, %xmm5
pshufd $0xb1, %xmm5, %xmm6 # xmm6 = xmm5[1,0,3,2]
pand %xmm5, %xmm6
packssdw %xmm7, %xmm6
pcmpeqd %xmm2, %xmm4
pshufd $0xb1, %xmm4, %xmm5 # xmm5 = xmm4[1,0,3,2]
pand %xmm4, %xmm5
pcmpeqd %xmm2, %xmm3
pshufd $0xb1, %xmm3, %xmm4 # xmm4 = xmm3[1,0,3,2]
pand %xmm3, %xmm4
packssdw %xmm5, %xmm4
packssdw %xmm6, %xmm4
packsswb %xmm4, %xmm4
pmovmskb %xmm4, %ecx
pcmpeqd %xmm2, %xmm1
pcmpeqd %xmm2, %xmm0
movdqa %xmm0, %xmm2
shufps $0xdd, %xmm1, %xmm2 # xmm2 = xmm2[1,3],xmm1[1,3]
shufps $0x88, %xmm1, %xmm0 # xmm0 = xmm0[0,2],xmm1[0,2]
andps %xmm2, %xmm0
movmskps %xmm0, %edx
orb %cl, %dl
sete %cl
testb %al, %cl
je 0x2b309
movq 0x215f0(%r14), %rdi
leaq 0x36215(%rip), %rsi # 0x6148b
callq 0x7520
movq %rax, 0x21660(%r14)
movq 0x215f0(%r14), %rdi
leaq 0x3620d(%rip), %rsi # 0x6149d
callq 0x7520
movq %rax, 0x21668(%r14)
movq 0x20640(%r14), %rdi
leaq 0x215ec(%r14), %rsi
leaq 0x215e8(%r14), %rdx
callq *0x21610(%r14)
testl %eax, %eax
je 0x2b32c
movq 0x20640(%r14), %rdi
leaq 0x215e0(%r14), %rsi
leaq 0x215e4(%r14), %rdx
callq *0x21618(%r14)
testl %eax, %eax
je 0x2b335
cmpl $0x1, 0x215e0(%r14)
jne 0x2b33e
cmpl $0x2, 0x215e4(%r14)
jg 0x2b33e
leaq 0x361f9(%rip), %rsi # 0x614f0
jmp 0x2b300
leaq 0x36058(%rip), %rsi # 0x61358
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
jmp 0x2b317
leaq 0x36151(%rip), %rsi # 0x61461
xorl %ebx, %ebx
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1eed8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3617f(%rip), %rsi # 0x614b2
jmp 0x2b300
leaq 0x36193(%rip), %rsi # 0x614cf
jmp 0x2b300
leaq 0x361cc(%rip), %rdi # 0x61511
callq 0x2b4eb
testl %eax, %eax
je 0x2b371
leaq 0x361d1(%rip), %rdi # 0x61526
callq 0x2b526
movq %rax, 0x21678(%r14)
testq %rax, %rax
je 0x2b371
movl $0x1, 0x21694(%r14)
leaq 0x361c1(%rip), %rdi # 0x61539
callq 0x2b4eb
testl %eax, %eax
je 0x2b3a4
leaq 0x361c6(%rip), %rdi # 0x6154e
callq 0x2b526
movq %rax, 0x21670(%r14)
testq %rax, %rax
je 0x2b3a4
movl $0x1, 0x21690(%r14)
leaq 0x361b6(%rip), %rdi # 0x61561
callq 0x2b4eb
testl %eax, %eax
je 0x2b3d7
leaq 0x361bc(%rip), %rdi # 0x61577
callq 0x2b526
movq %rax, 0x21680(%r14)
testq %rax, %rax
je 0x2b3d7
movl $0x1, 0x21698(%r14)
leaq 0x361ad(%rip), %rdi # 0x6158b
callq 0x2b4eb
testl %eax, %eax
je 0x2b3f2
movl $0x1, 0x2169c(%r14)
leaq 0x361a6(%rip), %rdi # 0x6159f
callq 0x2b4eb
testl %eax, %eax
je 0x2b40d
movl $0x1, 0x216a0(%r14)
leaq 0x361a4(%rip), %rdi # 0x615b8
callq 0x2b4eb
testl %eax, %eax
je 0x2b428
movl $0x1, 0x216a4(%r14)
leaq 0x361a2(%rip), %rdi # 0x615d1
callq 0x2b4eb
testl %eax, %eax
je 0x2b45b
leaq 0x361a9(%rip), %rdi # 0x615e8
callq 0x2b526
movq %rax, 0x21688(%r14)
testq %rax, %rax
je 0x2b45b
movl $0x1, 0x216a8(%r14)
leaq 0x361a1(%rip), %rdi # 0x61603
callq 0x2b4eb
testl %eax, %eax
je 0x2b476
movl $0x1, 0x216b0(%r14)
leaq 0x361a8(%rip), %rdi # 0x61625
callq 0x2b4eb
testl %eax, %eax
je 0x2b491
movl $0x1, 0x216ac(%r14)
leaq 0x361ac(%rip), %rdi # 0x61644
callq 0x2b4eb
testl %eax, %eax
je 0x2b4ac
movl $0x1, 0x216b4(%r14)
leaq 0x361b4(%rip), %rdi # 0x61667
callq 0x2b4eb
testl %eax, %eax
je 0x2b4c7
movl $0x1, 0x216b8(%r14)
leaq 0x361b9(%rip), %rdi # 0x61687
callq 0x2b4eb
testl %eax, %eax
je 0x2b31e
movl $0x1, 0x216bc(%r14)
jmp 0x2b31e
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_context.c |
getProcAddressGLX | static GLFWglproc getProcAddressGLX(const char* procname)
{
if (_glfw.glx.GetProcAddress)
return _glfw.glx.GetProcAddress((const GLubyte*) procname);
else if (_glfw.glx.GetProcAddressARB)
return _glfw.glx.GetProcAddressARB((const GLubyte*) procname);
else
return _glfw_dlsym(_glfw.glx.handle, procname);
} | movq %rdi, %rsi
leaq 0x45888(%rip), %rax # 0x70db8
movq 0x21660(%rax), %rcx
testq %rcx, %rcx
jne 0x2b548
movq 0x21668(%rax), %rcx
testq %rcx, %rcx
je 0x2b54d
movq %rsi, %rdi
jmpq *%rcx
movq 0x215f0(%rax), %rdi
jmp 0x7520
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_context.c |
glfwGetGLXContext | GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.source != GLFW_NATIVE_CONTEXT_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window->context.glx.handle;
} | pushq %rbx
leaq 0x44fb7(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x2be1b
cmpl $0x36001, 0x204(%rdi) # imm = 0x36001
jne 0x2be24
movq 0x278(%rdi), %rbx
jmp 0x2be34
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x2be2b
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq 0x1eed8
movq %rbx, %rax
popq %rbx
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_context.c |
glfwGetGLXWindow | GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(None);
if (window->context.source != GLFW_NATIVE_CONTEXT_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return None;
}
return window->context.glx.window;
} | pushq %rbx
leaq 0x44f77(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x2be5b
cmpl $0x36001, 0x204(%rdi) # imm = 0x36001
jne 0x2be64
movq 0x280(%rdi), %rbx
jmp 0x2be74
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x2be6b
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq 0x1eed8
movq %rbx, %rax
popq %rbx
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_context.c |
PDCLIB_prepwrite | int _PDCLIB_prepwrite( struct _PDCLIB_file_t * stream )
{
if ( ( stream->bufidx < stream->bufend ) || ( stream->ungetidx > 0 ) ||
( stream->status & ( _PDCLIB_FREAD | _PDCLIB_ERRORFLAG | _PDCLIB_WIDESTREAM | _PDCLIB_EOFFLAG ) ) ||
!( stream->status & ( _PDCLIB_FWRITE | _PDCLIB_FAPPEND | _PDCLIB_FRW ) ) )
{
/* Function called on illegal (e.g. input) stream. */
*_PDCLIB_errno_func() = _PDCLIB_EBADF;
stream->status |= _PDCLIB_ERRORFLAG;
return EOF;
}
stream->status |= _PDCLIB_FWRITE | _PDCLIB_BYTESTREAM;
return 0;
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x20(%rdi), %rax
jb 0x247d
cmpq $0x0, 0x38(%rbx)
jne 0x247d
movl 0x44(%rbx), %eax
testl $0xe08, %eax # imm = 0xE08
sete %cl
testb $0x70, %al
setne %dl
testb %dl, %cl
jne 0x2493
callq 0x3950
movl $0x9, (%rax)
orb $0x2, 0x45(%rbx)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
retq
orl $0x1010, %eax # imm = 0x1010
movl %eax, 0x44(%rbx)
xorl %eax, %eax
jmp 0x2491
nop
| /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_prepwrite.c |
memmove | void * memmove( void * s1, const void * s2, size_t n )
{
char * dest = ( char * ) s1;
const char * src = ( const char * ) s2;
if ( dest <= src )
{
while ( n-- )
{
*dest++ = *src++;
}
}
else
{
src += n;
dest += n;
while ( n-- )
{
*--dest = *--src;
}
}
return s1;
} | movq %rdi, %rax
cmpq %rsi, %rdi
jbe 0x3938
testq %rdx, %rdx
je 0x394f
movq %rdx, %rcx
movb -0x1(%rsi,%rdx), %dil
movb %dil, -0x1(%rax,%rdx)
decq %rcx
movq %rcx, %rdx
jne 0x3924
jmp 0x394f
testq %rdx, %rdx
je 0x394f
xorl %ecx, %ecx
movb (%rsi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rdx
jne 0x393f
retq
| /DevSolar[P]pdclib/functions/string/memmove.c |
cJSON_InitHooks | CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)
{
if (hooks == NULL)
{
/* Reset hooks */
global_hooks.allocate = malloc;
global_hooks.deallocate = free;
global_hooks.reallocate = realloc;
return;
}
global_hooks.allocate = malloc;
if (hooks->malloc_fn != NULL)
{
global_hooks.allocate = hooks->malloc_fn;
}
global_hooks.deallocate = free;
if (hooks->free_fn != NULL)
{
global_hooks.deallocate = hooks->free_fn;
}
/* use realloc only if both free and malloc are used */
global_hooks.reallocate = NULL;
if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free))
{
global_hooks.reallocate = realloc;
}
} | testq %rdi, %rdi
je 0x2293
movq 0x5d8b(%rip), %rdx # 0x7fe0
movq %rdx, 0x5e3c(%rip) # 0x8098
movq (%rdi), %rax
testq %rax, %rax
cmoveq %rdx, %rax
movq 0x5d53(%rip), %rsi # 0x7fc0
movq %rsi, 0x5e2c(%rip) # 0x80a0
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
cmoveq %rsi, %rcx
xorq %rax, %rdx
xorq %rcx, %rsi
orq %rdx, %rsi
jne 0x22aa
movq 0x5d57(%rip), %rdx # 0x7fe8
jmp 0x22ac
movq 0x5d4e(%rip), %rdx # 0x7fe8
movq 0x5d1f(%rip), %rcx # 0x7fc0
movq 0x5d38(%rip), %rax # 0x7fe0
jmp 0x22ac
xorl %edx, %edx
movq %rax, 0x5de5(%rip) # 0x8098
movq %rcx, 0x5de6(%rip) # 0x80a0
movq %rdx, 0x5de7(%rip) # 0x80a8
retq
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
buffer_skip_whitespace | static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
{
if ((buffer == NULL) || (buffer->content == NULL))
{
return NULL;
}
while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
{
buffer->offset++;
}
if (buffer->offset == buffer->length)
{
buffer->offset--;
}
return buffer;
} | testq %rdi, %rdi
je 0x294b
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x294b
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rax, %rcx
jae 0x293f
cmpb $0x20, (%rdx,%rcx)
ja 0x293f
incq %rcx
movq %rcx, 0x10(%rdi)
cmpq %rcx, %rax
jne 0x292b
jmp 0x2944
cmpq %rax, %rcx
jne 0x294b
decq %rax
movq %rax, 0x10(%rdi)
retq
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
print | static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)
{
printbuffer buffer[1];
unsigned char *printed = NULL;
memset(buffer, 0, sizeof(buffer));
/* create buffer */
buffer->buffer = (unsigned char*) hooks->allocate(256);
buffer->format = format;
buffer->hooks = *hooks;
if (buffer->buffer == NULL)
{
goto fail;
}
/* print the value */
if (!print_value(item, buffer))
{
goto fail;
}
update_offset(buffer);
/* check if reallocate is available */
if (hooks->reallocate != NULL)
{
printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->length);
buffer->buffer = NULL;
if (printed == NULL) {
goto fail;
}
}
else /* otherwise copy the JSON over to a new buffer */
{
printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
if (printed == NULL)
{
goto fail;
}
memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
printed[buffer->offset] = '\0'; /* just to be sure */
/* free the buffer */
hooks->deallocate(buffer->buffer);
}
return printed;
fail:
if (buffer->buffer != NULL)
{
hooks->deallocate(buffer->buffer);
}
if (printed != NULL)
{
hooks->deallocate(printed);
}
return NULL;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x100, %edi # imm = 0x100
callq *0x5705(%rip) # 0x8098
movq %rax, (%rsp)
movl %ebp, 0x24(%rsp)
movups 0x56f6(%rip), %xmm0 # 0x8098
movups %xmm0, 0x28(%rsp)
movq 0x56fa(%rip), %rcx # 0x80a8
movq %rcx, 0x38(%rsp)
testq %rax, %rax
je 0x2a68
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b35
movq (%r14), %rbx
testl %eax, %eax
je 0x2a5a
testq %rbx, %rbx
je 0x29f0
movq 0x10(%rsp), %r14
leaq (%rbx,%r14), %rdi
callq 0x2070
addq %r14, %rax
movq %rax, 0x10(%rsp)
movq 0x56b1(%rip), %rax # 0x80a8
testq %rax, %rax
je 0x2a0b
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *%rax
movq %rax, %r14
jmp 0x2a6b
movq 0x10(%rsp), %rdi
incq %rdi
callq *0x567f(%rip) # 0x8098
movq (%rsp), %rbx
testq %rax, %rax
je 0x2a5a
movq %rax, %r14
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
incq %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20c0
movq 0x10(%rsp), %rax
movb $0x0, (%r14,%rax)
movq (%rsp), %rdi
callq *0x5648(%rip) # 0x80a0
jmp 0x2a6b
testq %rbx, %rbx
je 0x2a68
movq %rbx, %rdi
callq *0x5638(%rip) # 0x80a0
xorl %r14d, %r14d
movq %fs:0x28, %rax
cmpq 0x48(%rsp), %rax
jne 0x2a87
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2080
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_PrintBuffered | CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)
{
printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
if (prebuffer < 0)
{
return NULL;
}
p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);
if (!p.buffer)
{
return NULL;
}
p.length = (size_t)prebuffer;
p.offset = 0;
p.noalloc = false;
p.format = fmt;
p.hooks = global_hooks;
if (!print_value(item, &p))
{
return NULL;
}
return (char*)p.buffer;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
movq $0x0, 0x20(%rsp)
testl %esi, %esi
js 0x2b12
movl %edx, %ebp
movq %rdi, %r14
movl %esi, %ebx
movq %rbx, %rdi
callq *0x55d2(%rip) # 0x8098
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2b12
leaq 0x8(%rsp), %rsi
movq %rbx, 0x8(%rsi)
xorl %ebx, %ebx
movq %rbx, 0x10(%rsi)
movl $0x0, 0x20(%rsi)
movl %ebp, 0x24(%rsi)
movups 0x55a8(%rip), %xmm0 # 0x8098
movups %xmm0, 0x28(%rsi)
movq 0x55ad(%rip), %rax # 0x80a8
movq %rax, 0x38(%rsi)
movq %r14, %rdi
callq 0x2b35
testl %eax, %eax
je 0x2b14
movq 0x8(%rsp), %rbx
jmp 0x2b14
xorl %ebx, %ebx
movq %fs:0x28, %rax
cmpq 0x48(%rsp), %rax
jne 0x2b30
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2080
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_AddItemToArray | CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item)
{
cJSON *child = NULL;
if ((item == NULL) || (array == NULL))
{
return;
}
child = array->child;
if (child == NULL)
{
/* list is empty, start new one */
array->child = item;
}
else
{
/* append to the end */
while (child->next)
{
child = child->next;
}
suffix_object(child, item);
}
} | testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x327b
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x327c
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
jne 0x3269
movq %rsi, (%rcx)
movq %rcx, 0x8(%rsi)
retq
movq %rsi, 0x10(%rdi)
retq
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_DetachItemFromObject | CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string)
{
cJSON *to_detach = cJSON_GetObjectItem(object, string);
return cJSON_DetachItemViaPointer(object, to_detach);
} | pushq %rbx
movq %rdi, %rbx
xorl %edx, %edx
callq 0x3159
testq %rbx, %rbx
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x3500
xorl %eax, %eax
jmp 0x3528
movq (%rax), %rcx
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x350f
movq %rcx, (%rdx)
testq %rcx, %rcx
je 0x3518
movq %rdx, 0x8(%rcx)
cmpq %rax, 0x10(%rbx)
jne 0x3522
movq %rcx, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rbx
retq
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_InsertItemInArray | CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)
{
cJSON *after_inserted = NULL;
if (which < 0)
{
return;
}
after_inserted = get_array_item(array, (size_t)which);
if (after_inserted == NULL)
{
cJSON_AddItemToArray(array, newitem);
return;
}
newitem->next = after_inserted;
newitem->prev = after_inserted->prev;
after_inserted->prev = newitem;
if (after_inserted == array->child)
{
array->child = newitem;
}
else
{
newitem->prev->next = newitem;
}
} | testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x35e1
movl %esi, %ecx
addq $0x10, %rdi
movq %rdi, %rax
movq (%rax), %rax
addq $-0x1, %rcx
setb %sil
testq %rax, %rax
je 0x35c1
testb %sil, %sil
jne 0x35ac
testq %rax, %rax
je 0x35e2
movq %rax, (%rdx)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq %rdx, 0x8(%rax)
cmpq (%rdi), %rax
je 0x3602
movq 0x8(%rdx), %rax
movq %rdx, (%rax)
retq
testq %rdx, %rdx
je 0x35e1
movq (%rdi), %rax
testq %rax, %rax
je 0x3602
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
jne 0x35ef
movq %rdx, (%rcx)
movq %rcx, 0x8(%rdx)
retq
movq %rdx, (%rdi)
retq
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
print_string_ptr | static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)
{
const unsigned char *input_pointer = NULL;
unsigned char *output = NULL;
unsigned char *output_pointer = NULL;
size_t output_length = 0;
/* numbers of additional characters needed for escaping */
size_t escape_characters = 0;
if (output_buffer == NULL)
{
return false;
}
/* empty string */
if (input == NULL)
{
output = ensure(output_buffer, sizeof("\"\""));
if (output == NULL)
{
return false;
}
strcpy((char*)output, "\"\"");
return true;
}
/* set "flag" to 1 if something needs to be escaped */
for (input_pointer = input; *input_pointer; input_pointer++)
{
switch (*input_pointer)
{
case '\"':
case '\\':
case '\b':
case '\f':
case '\n':
case '\r':
case '\t':
/* one character escape sequence */
escape_characters++;
break;
default:
if (*input_pointer < 32)
{
/* UTF-16 escape sequence uXXXX */
escape_characters += 5;
}
break;
}
}
output_length = (size_t)(input_pointer - input) + escape_characters;
output = ensure(output_buffer, output_length + sizeof("\"\""));
if (output == NULL)
{
return false;
}
/* no characters have to be escaped */
if (escape_characters == 0)
{
output[0] = '\"';
memcpy(output + 1, input, output_length);
output[output_length + 1] = '\"';
output[output_length + 2] = '\0';
return true;
}
output[0] = '\"';
output_pointer = output + 1;
/* copy the string */
for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)
{
if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\'))
{
/* normal character, copy */
*output_pointer = *input_pointer;
}
else
{
/* character needs to be escaped */
*output_pointer++ = '\\';
switch (*input_pointer)
{
case '\\':
*output_pointer = '\\';
break;
case '\"':
*output_pointer = '\"';
break;
case '\b':
*output_pointer = 'b';
break;
case '\f':
*output_pointer = 'f';
break;
case '\n':
*output_pointer = 'n';
break;
case '\r':
*output_pointer = 'r';
break;
case '\t':
*output_pointer = 't';
break;
default:
/* escape and print as unicode codepoint */
sprintf((char*)output_pointer, "u%04x", *input_pointer);
output_pointer += 4;
break;
}
}
}
output[output_length + 1] = '\"';
output[output_length + 2] = '\0';
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
testq %rdi, %rdi
je 0x4bac
movq %rdi, %rbx
xorl %r12d, %r12d
movabsq $0x400003700, %rcx # imm = 0x400003700
xorl %r13d, %r13d
movzbl (%rbx,%r12), %edx
cmpq $0x22, %rdx
ja 0x4ad0
btq %rdx, %rcx
jae 0x4acb
incq %r13
incq %r12
jmp 0x4ab2
testq %rdx, %rdx
je 0x4ae2
cmpl $0x5c, %edx
je 0x4ac3
leaq 0x5(%r13), %rsi
cmpb $0x20, %dl
cmovbq %rsi, %r13
jmp 0x4ac6
leaq (%r12,%r13), %rsi
addq $0x3, %rsi
movq %rax, %rdi
callq 0x49ab
testq %rax, %rax
je 0x4bc9
movq %rax, %r15
movb $0x22, (%rax)
testq %r13, %r13
je 0x4bcd
movb (%rbx), %al
testb %al, %al
je 0x4bdd
incq %rbx
leaq 0x53a(%rip), %rbp # 0x5058
movq %r15, %r14
cmpb $0x20, %al
jb 0x4b31
cmpb $0x22, %al
je 0x4b31
movzbl %al, %ecx
cmpl $0x5c, %ecx
jne 0x4b64
leaq 0x2(%r14), %rdi
movb $0x5c, 0x1(%r14)
movzbl -0x1(%rbx), %edx
leal -0x8(%rdx), %eax
cmpl $0x5, %eax
ja 0x4b55
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movb $0x62, (%rdi)
jmp 0x4b9a
cmpl $0x22, %edx
je 0x4b97
cmpl $0x5c, %edx
jne 0x4b6c
movb $0x5c, (%rdi)
jmp 0x4b9a
incq %r14
movb %al, (%r14)
jmp 0x4b7e
leaq 0x651(%rip), %rsi # 0x51c4
xorl %eax, %eax
callq 0x20e0
addq $0x6, %r14
movq %r14, %rdi
jmp 0x4b9a
movb $0x74, (%rdi)
jmp 0x4b9a
movb $0x6e, (%rdi)
jmp 0x4b9a
movb $0x66, (%rdi)
jmp 0x4b9a
movb $0x72, (%rdi)
jmp 0x4b9a
movb $0x22, (%rdi)
movb (%rbx), %al
incq %rbx
movq %rdi, %r14
testb %al, %al
jne 0x4b21
jmp 0x4bdd
movl $0x3, %esi
movq %rax, %rdi
callq 0x49ab
testq %rax, %rax
je 0x4bc9
movb $0x0, 0x2(%rax)
movw $0x2222, (%rax) # imm = 0x2222
jmp 0x4be8
xorl %eax, %eax
jmp 0x4bed
leaq (%r12,%r13), %rdx
leaq 0x1(%r15), %rdi
movq %rbx, %rsi
callq 0x20c0
addq %r13, %r15
movw $0x22, 0x1(%r12,%r15)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
SM83::ld_a_dde() | void SM83::ld_a_dde() {
LTRACE("LD A, (DE)");
a = bus.Read8(de);
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
leaq 0x24a51(%rip), %rdi # 0x30519
movl $0x48, %esi
movl $0x222222, %edx # imm = 0x222222
callq 0x1909f
movq 0x18(%rbx), %rdi
movzwl 0x4(%rbx), %esi
movl $0x1, %edx
callq 0x443e
movb %al, 0x1(%rbx)
addq $0x60, %rsp
popq %rbx
retq
| /tgsm[P]heliage/src/sm83.cpp |
SM83::ld_a_dhld() | void SM83::ld_a_dhld() {
LTRACE("LD A, (HL-)");
a = bus.Read8(hl--);
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
leaq 0x242fc(%rip), %rdi # 0x30562
movl $0x49, %esi
movl $0x222222, %edx # imm = 0x222222
callq 0x1909f
movq 0x18(%rbx), %rdi
movzwl 0x6(%rbx), %esi
leal -0x1(%rsi), %eax
movw %ax, 0x6(%rbx)
movl $0x1, %edx
callq 0x443e
movb %al, 0x1(%rbx)
addq $0x60, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
SM83::and_d8() | void SM83::and_d8() {
u8 value = GetByteFromPC();
LTRACE("AND 0x{:02X}", value);
a &= value;
SetZeroFlag(a == 0);
SetNegateFlag(false);
SetHalfCarryFlag(true);
SetCarryFlag(false);
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movzwl 0xa(%rbx), %esi
leal 0x1(%rsi), %eax
movw %ax, 0xa(%rbx)
movl $0x1, %edx
callq 0x443e
movzwl (%rbx), %edx
movq %rsp, %rcx
movq %rdx, (%rcx)
movzwl 0x2(%rbx), %edx
movq %rdx, 0x10(%rcx)
movzwl 0x4(%rbx), %edx
movq %rdx, 0x20(%rcx)
movzwl 0x6(%rbx), %edx
movq %rdx, 0x30(%rcx)
movzwl 0x8(%rbx), %edx
movq %rdx, 0x40(%rcx)
movzwl 0xc(%rbx), %edx
movq %rdx, 0x50(%rcx)
movzbl %al, %r14d
movq %r14, 0x60(%rcx)
leaq 0x2163d(%rip), %rdi # 0x2fe48
movl $0x4a, %esi
movl $0x2222222, %edx # imm = 0x2222222
callq 0x1909f
andb %r14b, 0x1(%rbx)
setne %al
movb (%rbx), %cl
andb $0xf, %cl
shlb $0x7, %al
orb %cl, %al
addb $-0x60, %al
movb %al, (%rbx)
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
SM83::ld_hl_sp_d8() | void SM83::ld_hl_sp_d8() {
s8 value = static_cast<s8>(GetByteFromPC());
LTRACE("LD HL, SP+0x{:02X}", value);
u32 result = sp + value;
SetZeroFlag(false);
SetNegateFlag(false);
SetHalfCarryFlag(((sp ^ value ^ (result & 0xFFFF)) & 0x10) == 0x10);
SetCarryFlag(((sp ^ value ^ (result & 0xFFFF)) & 0x100) == 0x100);
hl = static_cast<u16>(result);
timer.AdvanceCycles(4);
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movzwl 0xa(%rbx), %esi
leal 0x1(%rsi), %eax
movw %ax, 0xa(%rbx)
movl $0x1, %edx
callq 0x443e
movzwl (%rbx), %edx
movq %rsp, %rcx
movq %rdx, (%rcx)
movzwl 0x2(%rbx), %edx
movq %rdx, 0x10(%rcx)
movzwl 0x4(%rbx), %edx
movq %rdx, 0x20(%rcx)
movzwl 0x6(%rbx), %edx
movq %rdx, 0x30(%rcx)
movzwl 0x8(%rbx), %edx
movq %rdx, 0x40(%rcx)
movzwl 0xc(%rbx), %edx
movq %rdx, 0x50(%rcx)
movsbq %al, %r14
movl %r14d, %eax
movq %rax, 0x60(%rcx)
leaq 0x21a20(%rip), %rdi # 0x306e0
movl $0x50, %esi
movl $0x1222222, %edx # imm = 0x1222222
callq 0x1909f
movzwl 0x8(%rbx), %eax
movsbl %r14b, %ecx
leal (%rax,%rcx), %edx
movb (%rbx), %sil
movzbl %r14b, %edi
xorl %eax, %edi
xorl %edx, %edi
andb $0xf, %sil
addb %dil, %dil
andb $0x20, %dil
orb %sil, %dil
xorl %eax, %ecx
xorl %edx, %ecx
shrl $0x4, %ecx
andb $0x10, %cl
orb %dil, %cl
movb %cl, (%rbx)
movw %dx, 0x6(%rbx)
movq 0x20(%rbx), %rdi
movl $0x4, %esi
callq 0x17978
addq $0x78, %rsp
popq %rbx
popq %r14
retq
| /tgsm[P]heliage/src/sm83.cpp |
SM83::rl_dhl() | void SM83::rl_dhl() {
LTRACE("RL (HL)");
u8 value = bus.Read8(hl);
bool carry = HasFlag(Flags::Carry);
bool should_carry = value & (1 << 7);
SetCarryFlag(should_carry);
u8 result = value << 1;
result |= carry;
SetZeroFlag(result == 0);
SetNegateFlag(false);
SetHalfCarryFlag(false);
bus.Write8(hl, result);
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
leaq 0x216b5(%rip), %rdi # 0x30987
movl $0x45, %esi
movl $0x222222, %edx # imm = 0x222222
callq 0x1909f
movq 0x18(%rbx), %rdi
movzwl 0x6(%rbx), %esi
movl $0x1, %edx
callq 0x443e
movb (%rbx), %cl
movl %ecx, %edx
andb $0xf, %dl
movl %eax, %esi
shrb $0x3, %sil
andb $0x10, %sil
orb %dl, %sil
addb %al, %al
shrb $0x4, %cl
andb $0x1, %cl
orb %al, %cl
testb %cl, %cl
sete %al
shlb $0x7, %al
orb %sil, %al
movb %al, (%rbx)
movq 0x18(%rbx), %rdi
movzwl 0x6(%rbx), %esi
movzbl %cl, %edx
movl $0x1, %ecx
callq 0x46d2
addq $0x60, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void fmt::v11::print<unsigned short&, unsigned short&, unsigned short&, unsigned short&, unsigned short&, unsigned short&>(fmt::v11::basic_format_string<char, fmt::v11::type_identity<unsigned short&>::type, fmt::v11::type_identity<unsigned short&>::type, fmt::v11::type_identity<unsigned short&>::type, fmt::v11::type_identity<unsigned short&>::type, fmt::v11::type_identity<unsigned short&>::type, fmt::v11::type_identity<unsigned short&>::type>, unsigned short&, unsigned short&, unsigned short&, unsigned short&, unsigned short&, unsigned short&) | FMT_INLINE void print(format_string<T...> fmt, T&&... args) {
const auto& vargs = fmt::make_format_args(args...);
if (!detail::use_utf8()) return detail::vprint_mojibake(stdout, fmt, vargs);
return detail::is_locking<T...>() ? vprint_buffered(stdout, fmt, vargs)
: vprint(fmt, vargs);
} | subq $0x68, %rsp
movq 0x78(%rsp), %r10
movq 0x70(%rsp), %r11
movzwl (%rdx), %edx
movq %rsp, %rax
movq %rdx, (%rax)
movzwl (%rcx), %ecx
movq %rcx, 0x10(%rax)
movzwl (%r8), %ecx
movq %rcx, 0x20(%rax)
movzwl (%r9), %ecx
movq %rcx, 0x30(%rax)
movzwl (%r11), %ecx
movq %rcx, 0x40(%rax)
movzwl (%r10), %ecx
movq %rcx, 0x50(%rax)
movl $0x222222, %edx # imm = 0x222222
movq %rax, %rcx
callq 0x1909f
addq $0x68, %rsp
retq
| /tgsm[P]heliage/dependencies/fmt/include/fmt/base.h |
void SM83::ld_r_r<(SM83::Registers)2, (SM83::Registers)2>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | subq $0x88, %rsp
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movl $0x42, %eax
movq %rax, 0x60(%rcx)
movq %rax, 0x70(%rcx)
leaq 0x21069(%rip), %rdi # 0x30fd1
movl $0x47, %esi
movl $0x88222222, %edx # imm = 0x88222222
callq 0x1909f
addq $0x88, %rsp
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)2, (SM83::Registers)3>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movq $0x42, 0x60(%rcx)
movq $0x43, 0x70(%rcx)
leaq 0x20ffe(%rip), %rdi # 0x30fd1
movl $0x47, %esi
movl $0x88222222, %edx # imm = 0x88222222
callq 0x1909f
movb 0x2(%rbx), %al
movb %al, 0x3(%rbx)
addq $0x80, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)2, (SM83::Registers)4>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movq $0x42, 0x60(%rcx)
movq $0x44, 0x70(%rcx)
leaq 0x20f8c(%rip), %rdi # 0x30fd1
movl $0x47, %esi
movl $0x88222222, %edx # imm = 0x88222222
callq 0x1909f
movb 0x5(%rbx), %al
movb %al, 0x3(%rbx)
addq $0x80, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)2, (SM83::Registers)6>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movq $0x42, 0x60(%rcx)
movq $0x48, 0x70(%rcx)
leaq 0x20ea8(%rip), %rdi # 0x30fd1
movl $0x47, %esi
movl $0x88222222, %edx # imm = 0x88222222
callq 0x1909f
movb 0x7(%rbx), %al
movb %al, 0x3(%rbx)
addq $0x80, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)3, (SM83::Registers)2>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movq $0x43, 0x60(%rcx)
movq $0x42, 0x70(%rcx)
leaq 0x20d52(%rip), %rdi # 0x30fd1
movl $0x47, %esi
movl $0x88222222, %edx # imm = 0x88222222
callq 0x1909f
movb 0x3(%rbx), %al
movb %al, 0x2(%rbx)
addq $0x80, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)3, (SM83::Registers)0>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movq $0x43, 0x60(%rcx)
movq $0x41, 0x70(%rcx)
leaq 0x20ab4(%rip), %rdi # 0x30fd1
movl $0x47, %esi
movl $0x88222222, %edx # imm = 0x88222222
callq 0x1909f
movb 0x1(%rbx), %al
movb %al, 0x2(%rbx)
addq $0x80, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)5, (SM83::Registers)4>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movq $0x45, 0x60(%rcx)
movq $0x44, 0x70(%rcx)
leaq 0x2064e(%rip), %rdi # 0x30fd1
movl $0x47, %esi
movl $0x88222222, %edx # imm = 0x88222222
callq 0x1909f
movb 0x5(%rbx), %al
movb %al, 0x4(%rbx)
addq $0x80, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)6, (SM83::Registers)3>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movq $0x48, 0x60(%rcx)
movq $0x43, 0x70(%rcx)
leaq 0x203b0(%rip), %rdi # 0x30fd1
movl $0x47, %esi
movl $0x88222222, %edx # imm = 0x88222222
callq 0x1909f
movb 0x2(%rbx), %al
movb %al, 0x7(%rbx)
addq $0x80, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)7, (SM83::Registers)4>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movq $0x4c, 0x60(%rcx)
movq $0x44, 0x70(%rcx)
leaq 0x2002e(%rip), %rdi # 0x30fd1
movl $0x47, %esi
movl $0x88222222, %edx # imm = 0x88222222
callq 0x1909f
movb 0x5(%rbx), %al
movb %al, 0x6(%rbx)
addq $0x80, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)0, (SM83::Registers)5>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movq $0x41, 0x60(%rcx)
movq $0x45, 0x70(%rcx)
leaq 0x1fcac(%rip), %rdi # 0x30fd1
movl $0x47, %esi
movl $0x88222222, %edx # imm = 0x88222222
callq 0x1909f
movb 0x4(%rbx), %al
movb %al, 0x1(%rbx)
addq $0x80, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)0, (SM83::Registers)7>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movq $0x41, 0x60(%rcx)
movq $0x4c, 0x70(%rcx)
leaq 0x1fbc8(%rip), %rdi # 0x30fd1
movl $0x47, %esi
movl $0x88222222, %edx # imm = 0x88222222
callq 0x1909f
movb 0x6(%rbx), %al
movb %al, 0x1(%rbx)
addq $0x80, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::jp_a16<(SM83::Conditions)3>() | void SM83::jp_a16() {
const u16 addr = GetWordFromPC();
if constexpr (cond == Conditions::None) {
LTRACE("JP 0x{:04X}", addr);
} else {
LTRACE("JP {}, 0x{:04X}", GetConditionString<cond>(), addr);
}
if (MeetsCondition<cond>()) {
pc = addr;
timer.AdvanceCycles(4);
}
} | pushq %rbp
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0xb338
movl %eax, %ebp
movzwl (%rbx), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rbx), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rbx), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rbx), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rbx), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rbx), %eax
movq %rax, 0x50(%rcx)
leaq 0x1f6bb(%rip), %rax # 0x30fcc
movq %rax, 0x60(%rcx)
movq $0x1, 0x68(%rcx)
movzwl %bp, %eax
movq %rax, 0x70(%rcx)
leaq 0x1f77b(%rip), %rdi # 0x310a6
movl $0x4d, %esi
movl $0x2d222222, %edx # imm = 0x2D222222
callq 0x1909f
cmpb $0x0, (%rbx)
jns 0x11951
movw %bp, 0xa(%rbx)
movq 0x20(%rbx), %rdi
movl $0x4, %esi
callq 0x17978
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::call_a16<(SM83::Conditions)0>() | void SM83::call_a16() {
const u16 address = GetWordFromPC();
if constexpr (cond == Conditions::None) {
LTRACE("CALL 0x{:04X}", address);
} else {
LTRACE("CALL {}, 0x{:04X}", GetConditionString<cond>(), address);
}
if (MeetsCondition<cond>()) {
StackPush(pc);
pc = address;
timer.AdvanceCycles(4);
}
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0xb338
movzwl (%rbx), %edx
movq %rsp, %rcx
movq %rdx, (%rcx)
movzwl 0x2(%rbx), %edx
movq %rdx, 0x10(%rcx)
movzwl 0x4(%rbx), %edx
movq %rdx, 0x20(%rcx)
movzwl 0x6(%rbx), %edx
movq %rdx, 0x30(%rcx)
movzwl 0x8(%rbx), %edx
movq %rdx, 0x40(%rcx)
movzwl 0xc(%rbx), %edx
movq %rdx, 0x50(%rcx)
movzwl %ax, %r14d
movq %r14, 0x60(%rcx)
leaq 0x1f7c9(%rip), %rdi # 0x31216
movl $0x4b, %esi
movl $0x2222222, %edx # imm = 0x2222222
callq 0x1909f
movzwl 0xa(%rbx), %esi
movq %rbx, %rdi
callq 0xb3ce
movw %r14w, 0xa(%rbx)
movq 0x20(%rbx), %rdi
movl $0x4, %esi
callq 0x17978
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::pop_rr<(SM83::Registers)10>() | void SM83::pop_rr() {
LTRACE("POP {}", Get16bitRegisterName<Register>());
StackPop(Get16bitRegisterPointer<Register>());
if constexpr (Register == Registers::AF) {
// Lowest 4 bits are always 0
f &= ~0x0F;
}
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x4(%rdi), %r14
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
leaq 0x1f70c(%rip), %rax # 0x31262
movq %rax, 0x60(%rcx)
movq $0x2, 0x68(%rcx)
leaq 0x1f4f5(%rip), %rdi # 0x3105e
movl $0x44, %esi
movl $0xd222222, %edx # imm = 0xD222222
callq 0x1909f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb41e
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::call_a16<(SM83::Conditions)2>() | void SM83::call_a16() {
const u16 address = GetWordFromPC();
if constexpr (cond == Conditions::None) {
LTRACE("CALL 0x{:04X}", address);
} else {
LTRACE("CALL {}, 0x{:04X}", GetConditionString<cond>(), address);
}
if (MeetsCondition<cond>()) {
StackPush(pc);
pc = address;
timer.AdvanceCycles(4);
}
} | pushq %rbp
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0xb338
movl %eax, %ebp
movzwl (%rbx), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rbx), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rbx), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rbx), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rbx), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rbx), %eax
movq %rax, 0x50(%rcx)
leaq 0x1f361(%rip), %rax # 0x30fce
movq %rax, 0x60(%rcx)
movq $0x2, 0x68(%rcx)
movzwl %bp, %eax
movq %rax, 0x70(%rcx)
leaq 0x1f4b7(%rip), %rdi # 0x3113e
movl $0x4f, %esi
movl $0x2d222222, %edx # imm = 0x2D222222
callq 0x1909f
testb $0x10, (%rbx)
jne 0x11cb9
movzwl 0xa(%rbx), %esi
movq %rbx, %rdi
callq 0xb3ce
movw %bp, 0xa(%rbx)
movq 0x20(%rbx), %rdi
movl $0x4, %esi
callq 0x17978
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::pop_rr<(SM83::Registers)11>() | void SM83::pop_rr() {
LTRACE("POP {}", Get16bitRegisterName<Register>());
StackPop(Get16bitRegisterPointer<Register>());
if constexpr (Register == Registers::AF) {
// Lowest 4 bits are always 0
f &= ~0x0F;
}
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x6(%rdi), %r14
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
leaq 0x1f315(%rip), %rax # 0x31265
movq %rax, 0x60(%rcx)
movq $0x2, 0x68(%rcx)
leaq 0x1f0fb(%rip), %rdi # 0x3105e
movl $0x44, %esi
movl $0xd222222, %edx # imm = 0xD222222
callq 0x1909f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb41e
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::push_rr<(SM83::Registers)11>() | void SM83::push_rr() {
LTRACE("PUSH {}", Get16bitRegisterName<Register>());
StackPush(Get16bitRegister<Register>());
timer.AdvanceCycles(4);
} | pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
leaq 0x1f29f(%rip), %rax # 0x31265
movq %rax, 0x60(%rcx)
movq $0x2, 0x68(%rcx)
leaq 0x1f1b5(%rip), %rdi # 0x3118e
movl $0x45, %esi
movl $0xd222222, %edx # imm = 0xD222222
callq 0x1909f
movzwl 0x6(%rbx), %esi
movq %rbx, %rdi
callq 0xb3ce
movq 0x20(%rbx), %rdi
movl $0x4, %esi
callq 0x17978
addq $0x70, %rsp
popq %rbx
retq
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::pop_rr<(SM83::Registers)8>() | void SM83::pop_rr() {
LTRACE("POP {}", Get16bitRegisterName<Register>());
StackPop(Get16bitRegisterPointer<Register>());
if constexpr (Register == Registers::AF) {
// Lowest 4 bits are always 0
f &= ~0x0F;
}
} | pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
leaq 0x1f220(%rip), %rax # 0x31268
movq %rax, 0x60(%rcx)
movq $0x2, 0x68(%rcx)
leaq 0x1f003(%rip), %rdi # 0x3105e
movl $0x44, %esi
movl $0xd222222, %edx # imm = 0xD222222
callq 0x1909f
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xb41e
andb $-0x10, (%rbx)
addq $0x70, %rsp
popq %rbx
retq
| /tgsm[P]heliage/src/sm83.cpp |
void SM83::push_rr<(SM83::Registers)8>() | void SM83::push_rr() {
LTRACE("PUSH {}", Get16bitRegisterName<Register>());
StackPush(Get16bitRegister<Register>());
timer.AdvanceCycles(4);
} | pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
leaq 0x1f1aa(%rip), %rax # 0x31268
movq %rax, 0x60(%rcx)
movq $0x2, 0x68(%rcx)
leaq 0x1f0bd(%rip), %rdi # 0x3118e
movl $0x45, %esi
movl $0xd222222, %edx # imm = 0xD222222
callq 0x1909f
movzwl (%rbx), %esi
movq %rbx, %rdi
callq 0xb3ce
movq 0x20(%rbx), %rdi
movl $0x4, %esi
callq 0x17978
addq $0x70, %rsp
popq %rbx
retq
nop
| /tgsm[P]heliage/src/sm83.cpp |
cloexec_pipe | int cloexec_pipe(int fds[2])
{
#ifdef __linux__
return pipe2(fds, O_CLOEXEC);
#else
int ret = -1;
pthread_mutex_lock(&cloexec_mutex);
if (pipe(fds) != 0)
goto Exit;
if (set_cloexec(fds[0]) != 0 || set_cloexec(fds[1]) != 0)
goto Exit;
ret = 0;
Exit:
pthread_mutex_unlock(&cloexec_mutex);
return ret;
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x80000, %esi # imm = 0x80000
callq 0x40880
addq $0x10, %rsp
popq %rbp
retq
| /urbit[P]h2o/deps/cloexec/cloexec.c |
gkc_summary_free | void gkc_summary_free(struct gkc_summary *s)
{
struct freelist *fl;
struct list *cur;
cur = s->head.next;
while (cur != &s->head) {
struct list *next;
next = cur->next;
gkc_free(s, list_to_tuple(cur));
cur = next;
}
fl = s->fl;
while (fl) {
void *p;
p = fl;
fl = fl->next;
free(p);
}
free(s);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
je 0x40fda
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rax
addq $0x18, %rax
subq %rax, %rsi
addq -0x18(%rbp), %rsi
callq 0x41020
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x40f98
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4100b
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3f330
jmp 0x40fe6
movq -0x8(%rbp), %rdi
callq 0x3f330
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /urbit[P]h2o/deps/libgkc/gkc.c |
gkc_query | uint64_t gkc_query(struct gkc_summary *s, double q)
{
struct list *cur, *next;
int rank;
double gi;
double ne;
rank = 0.5 + q * s->nr_elems;
ne = s->nr_elems * s->epsilon;
gi = 0;
if (list_empty(&s->head)) {
return 0;
}
cur = s->head.next;
while (1) {
struct gkc_tuple *tcur, *tnext;
tcur = list_to_tuple(cur);
next = cur->next;
if (next == &s->head) {
return tcur->value;
}
tnext = list_to_tuple(next);
gi += tcur->g;
if ((rank + ne) < (gi + tnext->g + tnext->delta)) {
if ((rank + ne) < (gi + tnext->g)) {
return tcur->value;
}
return tnext->value;
}
cur = next;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq (%rax), %xmm3
movaps 0xf2f9b(%rip), %xmm2 # 0x134030
punpckldq %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movapd 0xf2f9f(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm3
movaps %xmm3, %xmm4
unpckhpd %xmm3, %xmm3 # xmm3 = xmm3[1,1]
addsd %xmm4, %xmm3
mulsd %xmm3, %xmm0
movsd 0xf2f64(%rip), %xmm3 # 0x134020
addsd %xmm3, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %xmm0
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
mulsd 0x8(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x41230
cmpl $0x0, %eax
je 0x41117
movq $0x0, -0x8(%rbp)
jmp 0x4121d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movq %rax, %rcx
addq $0x18, %rcx
subq %rcx, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x41164
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4121d
movq -0x28(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movsd 0x8(%rax), %xmm1
movsd -0x38(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
cvtsi2sdl -0x2c(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
addsd %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
movq -0x50(%rbp), %rax
movsd 0x8(%rax), %xmm2
addsd %xmm2, %xmm0
movq 0x10(%rax), %xmm2
movaps 0xf2e7d(%rip), %xmm3 # 0x134030
punpckldq %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movapd 0xf2e81(%rip), %xmm3 # 0x134040
subpd %xmm3, %xmm2
movaps %xmm2, %xmm3
unpckhpd %xmm2, %xmm2 # xmm2 = xmm2[1,1]
addsd %xmm3, %xmm2
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x41210
cvtsi2sdl -0x2c(%rbp), %xmm1
addsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movq -0x50(%rbp), %rax
addsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x41203
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4121d
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4121d
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x41123
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /urbit[P]h2o/deps/libgkc/gkc.c |
gkc_alloc | static struct gkc_tuple *gkc_alloc(struct gkc_summary *s)
{
s->alloced++;
if (s->alloced > s->max_alloced) {
s->max_alloced = s->alloced;
}
if (s->fl) {
void *ret;
ret = s->fl;
s->fl = s->fl->next;
return ret;
}
return malloc(sizeof(struct gkc_tuple));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x4151e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x41552
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x41560
movl $0x28, %edi
callq 0x40240
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /urbit[P]h2o/deps/libgkc/gkc.c |
gkc_print_summary | void gkc_print_summary(struct gkc_summary *s)
{
struct gkc_tuple *tcur;
struct list *cur;
fprintf(stderr, "nr_elems: %zu, epsilon: %.02f, alloced: %" PRIu64 ", overfilled: %.02f, max_alloced: %" PRIu64 "\n",
s->nr_elems, s->epsilon, s->alloced, 2 * s->epsilon * s->nr_elems, s->max_alloced);
if (list_empty(&s->head)) {
fprintf(stderr, "Empty summary\n");
return;
}
cur = s->head.next;
while (cur != &s->head) {
tcur = list_to_tuple(cur);
fprintf(stderr, "(v: %" PRIu64 ", g: %.02f, d: %" PRIu64 ") ", tcur->value, tcur->g, tcur->delta);
cur = cur->next;
}
fprintf(stderr, "\n");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1aa825(%rip), %rax # 0x1ebfb8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movsd 0x8(%rax), %xmm0
movq 0x10(%rax), %rcx
movaps %xmm0, %xmm1
addsd %xmm1, %xmm1
movq %rdx, %xmm2
movaps 0xf2877(%rip), %xmm3 # 0x134030
punpckldq %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movapd 0xf287b(%rip), %xmm3 # 0x134040
subpd %xmm3, %xmm2
movaps %xmm2, %xmm3
unpckhpd %xmm2, %xmm2 # xmm2 = xmm2[1,1]
addsd %xmm3, %xmm2
mulsd %xmm2, %xmm1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %r8
leaq 0xf296c(%rip), %rsi # 0x134153
movb $0x2, %al
callq 0x3f380
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x41230
cmpl $0x0, %eax
je 0x4181d
movq 0x1aa7b1(%rip), %rax # 0x1ebfb8
movq (%rax), %rdi
leaq 0xf2994(%rip), %rsi # 0x1341a5
movb $0x0, %al
callq 0x3f380
jmp 0x418a4
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
je 0x4188c
xorl %eax, %eax
movq %rax, %rcx
addq $0x18, %rcx
subq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x1aa763(%rip), %rax # 0x1ebfb8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0xf293d(%rip), %rsi # 0x1341b4
movb $0x1, %al
callq 0x3f380
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x41829
movq 0x1aa725(%rip), %rax # 0x1ebfb8
movq (%rax), %rdi
leaq 0x17a5cb(%rip), %rsi # 0x1bbe68
movb $0x0, %al
callq 0x3f380
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /urbit[P]h2o/deps/libgkc/gkc.c |
gkc_combine | struct gkc_summary *gkc_combine(struct gkc_summary *s1, struct gkc_summary *s2)
{
struct gkc_summary *snew;
struct list *cur1, *cur2;
struct gkc_tuple *tcur1, *tcur2, *tnew;
if (s1->epsilon != s2->epsilon) {
return NULL;
}
snew = gkc_summary_alloc(s1->epsilon);
cur1 = s1->head.next;
cur2 = s2->head.next;
while (cur1 != &s1->head && cur2 != &s2->head) {
tcur1 = list_to_tuple(cur1);
tcur2 = list_to_tuple(cur2);
tnew = gkc_alloc(snew);
if (tcur1->value < tcur2->value) {
tnew->value = tcur1->value;
tnew->g = tcur1->g;
tnew->delta = tcur1->delta;
cur1 = cur1->next;
} else {
tnew->value = tcur2->value;
tnew->g = tcur2->g;
tnew->delta = tcur2->delta;
cur2 = cur2->next;
}
list_add_tail(&snew->head, &tnew->node);
snew->nr_elems += tnew->g;
}
while (cur1 != &s1->head) {
tcur1 = list_to_tuple(cur1);
tnew = gkc_alloc(snew);
tnew->value = tcur1->value;
tnew->g = tcur1->g;
tnew->delta = tcur1->delta;
list_add_tail(&snew->head, &tnew->node);
snew->nr_elems += tnew->g;
cur1 = cur1->next;
}
while (cur2 != &s2->head) {
tcur2 = list_to_tuple(cur2);
tnew = gkc_alloc(snew);
tnew->value = tcur2->value;
tnew->g = tcur2->g;
tnew->delta = tcur2->delta;
list_add_tail(&snew->head, &tnew->node);
snew->nr_elems += tnew->g;
cur2 = cur2->next;
}
snew->max_alloced = snew->alloced;
gkc_compress(snew);
return snew;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x418d8
jp 0x418d8
jmp 0x418e5
movq $0x0, -0x8(%rbp)
jmp 0x41c6c
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x40d20
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x49(%rbp)
je 0x4193a
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x41946
jmp 0x41a7f
xorl %eax, %eax
movq %rax, %rcx
addq $0x18, %rcx
subq %rcx, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
movq %rax, %rcx
addq $0x18, %rcx
subq %rcx, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x414e0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x419c9
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x48(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x41a05
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x48(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x48(%rbp), %rsi
addq $0x18, %rsi
callq 0x415c0
movq -0x48(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x20(%rbp), %rax
movq (%rax), %xmm0
movaps 0xf25fe(%rip), %xmm2 # 0x134030
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0xf2602(%rip), %xmm2 # 0x134040
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movsd 0xf25a8(%rip), %xmm1 # 0x134010
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x4190f
jmp 0x41a81
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
je 0x41b65
movq -0x28(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x414e0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x48(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x48(%rbp), %rsi
addq $0x18, %rsi
callq 0x415c0
movq -0x48(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x20(%rbp), %rax
movq (%rax), %xmm0
movaps 0xf2524(%rip), %xmm2 # 0x134030
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0xf2528(%rip), %xmm2 # 0x134040
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movsd 0xf24ce(%rip), %xmm1 # 0x134010
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x41a81
jmp 0x41b67
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
je 0x41c4b
movq -0x30(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x414e0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x48(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x48(%rbp), %rsi
addq $0x18, %rsi
callq 0x415c0
movq -0x48(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x20(%rbp), %rax
movq (%rax), %xmm0
movaps 0xf243e(%rip), %xmm2 # 0x134030
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0xf2442(%rip), %xmm2 # 0x134040
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movsd 0xf23e8(%rip), %xmm1 # 0x134010
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x41b67
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
callq 0x415f0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/deps/libgkc/gkc.c |
band | static uint64_t band(struct gkc_summary *s, uint64_t delta)
{
uint64_t diff;
diff = 1 + (s->epsilon * s->nr_elems * 2) - delta;
if (diff == 1) {
return 0;
} else {
return ullog2(diff)/ullog2(2);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq (%rax), %xmm1
movaps 0xf238c(%rip), %xmm3 # 0x134030
punpckldq %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movapd 0xf2390(%rip), %xmm2 # 0x134040
subpd %xmm2, %xmm1
movaps %xmm1, %xmm4
unpckhpd %xmm1, %xmm1 # xmm1 = xmm1[1,1]
addsd %xmm4, %xmm1
mulsd %xmm1, %xmm0
addsd %xmm0, %xmm0
movsd 0xf2339(%rip), %xmm1 # 0x134008
addsd %xmm1, %xmm0
movq -0x18(%rbp), %xmm1
punpckldq %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1 # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0xf230a(%rip), %xmm1 # 0x134010
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jne 0x41d2a
movq $0x0, -0x8(%rbp)
jmp 0x41d51
movq -0x20(%rbp), %rdi
callq 0x41d90
movq %rax, -0x28(%rbp)
movl $0x2, %edi
callq 0x41d90
movq %rax, %rcx
movq -0x28(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /urbit[P]h2o/deps/libgkc/gkc.c |
ullog2 | static uint64_t ullog2(uint64_t x)
{
static const uint64_t debruijn_magic = 0x022fdd63cc95386dULL;
static const uint64_t magic_table[] = {
0, 1, 2, 53, 3, 7, 54, 27, 4, 38, 41, 8, 34, 55, 48, 28,
62, 5, 39, 46, 44, 42, 22, 9, 24, 35, 59, 56, 49, 18, 29, 11,
63, 52, 6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10,
51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12,
};
x |= (x >> 1);
x |= (x >> 2);
x |= (x >> 4);
x |= (x >> 8);
x |= (x >> 16);
x |= (x >> 32);
return (magic_table[((x & ~(x>>1))*debruijn_magic)>>58]);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x4, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x8, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x10, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
shrq %rax
xorq $-0x1, %rax
andq %rax, %rcx
movabsq $0x22fdd63cc95386d, %rax # imm = 0x22FDD63CC95386D
imulq %rax, %rcx
shrq $0x3a, %rcx
leaq 0xf23be(%rip), %rax # 0x1341e0
movq (%rax,%rcx,8), %rax
popq %rbp
retq
nopl (%rax,%rax)
| /urbit[P]h2o/deps/libgkc/gkc.c |
yrmcds_close | yrmcds_error yrmcds_close(yrmcds* c) {
if( c == NULL )
return YRMCDS_BAD_ARGUMENT;
if( c->sock == -1 )
return YRMCDS_OK;
close(c->sock);
c->sock = -1;
#ifndef LIBYRMCDS_NO_INTERNAL_LOCK
pthread_mutex_destroy(&(c->lock));
#endif
free(c->recvbuf);
c->recvbuf = NULL;
free(c->decompressed);
c->decompressed = NULL;
return YRMCDS_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x41e4c
movl $0x2, -0x4(%rbp)
jmp 0x41eb9
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x41e5e
movl $0x0, -0x4(%rbp)
jmp 0x41eb9
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x3f450
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3f230
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3f330
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x3f330
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /urbit[P]h2o/deps/libyrmcds/close.c |
yrmcds_connect | yrmcds_error yrmcds_connect(yrmcds* c, const char* node, uint16_t port) {
if( c == NULL )
return YRMCDS_BAD_ARGUMENT;
#ifndef LIBYRMCDS_NO_INTERNAL_LOCK
int e = pthread_mutex_init(&(c->lock), NULL);
if( e != 0 ) {
errno = e;
return YRMCDS_SYSTEM_ERROR;
}
#endif // ! LIBYRMCDS_NO_INTERNAL_LOCK
int server_fd;
yrmcds_error err = connect_to_server(node, port, &server_fd);
if( err != YRMCDS_OK )
return err;
c->sock = server_fd;
c->serial = 0;
c->compress_size = 0;
c->recvbuf = (char*)malloc(1 << 20);
if( c->recvbuf == NULL ) {
close(server_fd);
#ifndef LIBYRMCDS_NO_INTERNAL_LOCK
pthread_mutex_destroy(&(c->lock));
#endif
return YRMCDS_OUT_OF_MEMORY;
}
c->capacity = 1 << 20;
c->used = 0;
c->last_size = 0;
c->decompressed = NULL;
c->invalid = 0;
c->text_mode = 0;
c->rserial = 0;
return YRMCDS_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x41efa
movl $0x2, -0x4(%rbp)
jmp 0x4200b
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3f710
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x41f30
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x40440
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4200b
movq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rdx
movzwl -0x1a(%rbp), %esi
callq 0x42020
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x41f55
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4200b
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movl $0x100000, %edi # imm = 0x100000
callq 0x40240
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x41fb3
movl -0x24(%rbp), %edi
callq 0x3f450
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3f230
movl $0x6, -0x4(%rbp)
jmp 0x4200b
movq -0x10(%rbp), %rax
movq $0x100000, 0x48(%rax) # imm = 0x100000
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x6c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x70(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/deps/libyrmcds/connect.c |
connect_to_server | static yrmcds_error connect_to_server(const char* node, uint16_t port, int* server_fd) {
if( node == NULL )
return YRMCDS_BAD_ARGUMENT;
long fl;
char sport[8];
snprintf(sport, sizeof(sport), "%u", (unsigned int)port);
struct addrinfo hint, *res;
memset(&hint, 0, sizeof(hint));
hint.ai_family = AF_INET; // prefer IPv4
hint.ai_socktype = SOCK_STREAM;
hint.ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG;
int e = getaddrinfo(node, sport, &hint, &res);
if( e == EAI_FAMILY || e == EAI_NONAME
#ifdef EAI_ADDRFAMILY
|| e == EAI_ADDRFAMILY
#endif
#ifdef EAI_NODATA
|| e == EAI_NODATA
#endif
) {
hint.ai_family = AF_INET6;
// intentionally drop AI_ADDRCONFIG to support IPv6 link-local address.
// see https://github.com/cybozu/yrmcds/issues/40
hint.ai_flags = AI_NUMERICSERV|AI_V4MAPPED;
e = getaddrinfo(node, sport, &hint, &res);
}
if( e == EAI_SYSTEM ) {
return YRMCDS_SYSTEM_ERROR;
} else if( e != 0 ) {
return YRMCDS_NOT_RESOLVED;
}
int s = socket(res->ai_family,
res->ai_socktype
#ifdef __linux__
| SOCK_NONBLOCK | SOCK_CLOEXEC
#endif
, res->ai_protocol);
if( s == -1 ) {
e = errno;
freeaddrinfo(res);
errno = e;
return YRMCDS_SYSTEM_ERROR;
}
#ifndef __linux__
fl = fcntl(s, F_GETFD, 0);
fcntl(s, F_SETFD, fl | FD_CLOEXEC);
fl = fcntl(s, F_GETFL, 0);
fcntl(s, F_SETFL, fl | O_NONBLOCK);
#endif
e = connect(s, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
if( e == -1 && errno != EINPROGRESS ) {
e = errno;
close(s);
errno = e;
return YRMCDS_SYSTEM_ERROR;
}
if( e != 0 ) {
struct pollfd fds;
fds.fd = s;
fds.events = POLLOUT;
int n = poll(&fds, 1, 5000);
if( n == 0 ) { // timeout
close(s);
return YRMCDS_TIMEOUT;
}
if( n == -1 ) {
e = errno;
close(s);
errno = e;
return YRMCDS_SYSTEM_ERROR;
}
if( fds.revents & (POLLERR|POLLHUP|POLLNVAL) ) {
close(s);
return YRMCDS_DISCONNECTED;
}
socklen_t l = sizeof(e);
if( getsockopt(s, SOL_SOCKET, SO_ERROR, &e, &l) == -1 ) {
close(s);
return YRMCDS_SYSTEM_ERROR;
}
if( e != 0 ) {
close(s);
errno = e;
return YRMCDS_SYSTEM_ERROR;
}
}
fl = fcntl(s, F_GETFL, 0);
if( fcntl(s, F_SETFL, fl & ~O_NONBLOCK) == -1 ) {
e = errno;
close(s);
errno = e;
return YRMCDS_SYSTEM_ERROR;
}
int ok = 1;
if( setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &ok, sizeof(ok)) == -1 ) {
e = errno;
close(s);
errno = e;
return YRMCDS_SYSTEM_ERROR;
}
*server_fd = s;
return YRMCDS_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4204d
movl $0x2, -0x4(%rbp)
jmp 0x423cd
leaq -0x30(%rbp), %rdi
movzwl -0x12(%rbp), %ecx
movl $0x8, %esi
leaq 0xf777e(%rip), %rdx # 0x1397df
movb $0x0, %al
callq 0x3f9b0
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x3f5b0
movl $0x2, -0x5c(%rbp)
movl $0x1, -0x58(%rbp)
movl $0x420, -0x60(%rbp) # imm = 0x420
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x40700
movl %eax, -0x6c(%rbp)
cmpl $-0x6, -0x6c(%rbp)
je 0x420bd
cmpl $-0x2, -0x6c(%rbp)
je 0x420bd
cmpl $-0x9, -0x6c(%rbp)
je 0x420bd
cmpl $-0x5, -0x6c(%rbp)
jne 0x420e3
movl $0xa, -0x5c(%rbp)
movl $0x408, -0x60(%rbp) # imm = 0x408
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x40700
movl %eax, -0x6c(%rbp)
cmpl $-0xb, -0x6c(%rbp)
jne 0x420f5
movl $0x1, -0x4(%rbp)
jmp 0x423cd
cmpl $0x0, -0x6c(%rbp)
je 0x42107
movl $0x3, -0x4(%rbp)
jmp 0x423cd
jmp 0x42109
movq -0x68(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x68(%rbp), %rax
movl 0x8(%rax), %esi
orl $0x800, %esi # imm = 0x800
orl $0x80000, %esi # imm = 0x80000
movq -0x68(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x3f900
movl %eax, -0x70(%rbp)
cmpl $-0x1, -0x70(%rbp)
jne 0x4216d
callq 0x40440
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movq -0x68(%rbp), %rdi
callq 0x3fc80
movl -0x6c(%rbp), %eax
movl %eax, -0x90(%rbp)
callq 0x40440
movl -0x90(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x423cd
movl -0x70(%rbp), %edi
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x78(%rbp), %rsi
callq 0x3f700
movl %eax, -0x6c(%rbp)
movq -0x68(%rbp), %rdi
callq 0x3fc80
cmpl $-0x1, -0x6c(%rbp)
jne 0x421dc
callq 0x40440
cmpl $0x73, (%rax)
je 0x421dc
callq 0x40440
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x70(%rbp), %edi
callq 0x3f450
movl -0x6c(%rbp), %eax
movl %eax, -0x94(%rbp)
callq 0x40440
movl -0x94(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x423cd
cmpl $0x0, -0x6c(%rbp)
je 0x422f7
movl -0x70(%rbp), %eax
movl %eax, -0x80(%rbp)
movw $0x4, -0x7c(%rbp)
leaq -0x80(%rbp), %rdi
movl $0x1, %esi
movl $0x1388, %edx # imm = 0x1388
callq 0x3f570
movl %eax, -0x84(%rbp)
cmpl $0x0, -0x84(%rbp)
jne 0x42228
movl -0x70(%rbp), %edi
callq 0x3f450
movl $0x4, -0x4(%rbp)
jmp 0x423cd
cmpl $-0x1, -0x84(%rbp)
jne 0x42265
callq 0x40440
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x70(%rbp), %edi
callq 0x3f450
movl -0x6c(%rbp), %eax
movl %eax, -0x98(%rbp)
callq 0x40440
movl -0x98(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x423cd
movswl -0x7a(%rbp), %eax
andl $0x38, %eax
cmpl $0x0, %eax
je 0x42285
movl -0x70(%rbp), %edi
callq 0x3f450
movl $0x5, -0x4(%rbp)
jmp 0x423cd
movl $0x4, -0x88(%rbp)
movl -0x70(%rbp), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x6c(%rbp), %rcx
leaq -0x88(%rbp), %r8
callq 0x3fe50
cmpl $-0x1, %eax
jne 0x422c5
movl -0x70(%rbp), %edi
callq 0x3f450
movl $0x1, -0x4(%rbp)
jmp 0x423cd
cmpl $0x0, -0x6c(%rbp)
je 0x422f5
movl -0x70(%rbp), %edi
callq 0x3f450
movl -0x6c(%rbp), %eax
movl %eax, -0x9c(%rbp)
callq 0x40440
movl -0x9c(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x423cd
jmp 0x422f7
movl -0x70(%rbp), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x3f2a0
cltq
movq %rax, -0x28(%rbp)
movl -0x70(%rbp), %edi
movq -0x28(%rbp), %rdx
andq $-0x801, %rdx # imm = 0xF7FF
movl $0x4, %esi
movb $0x0, %al
callq 0x3f2a0
cmpl $-0x1, %eax
jne 0x4235e
callq 0x40440
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x70(%rbp), %edi
callq 0x3f450
movl -0x6c(%rbp), %eax
movl %eax, -0xa0(%rbp)
callq 0x40440
movl -0xa0(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x423cd
movl $0x1, -0x8c(%rbp)
movl -0x70(%rbp), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x8c(%rbp), %rcx
movl $0x4, %r8d
callq 0x3f290
cmpl $-0x1, %eax
jne 0x423bd
callq 0x40440
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x70(%rbp), %edi
callq 0x3f450
movl -0x6c(%rbp), %eax
movl %eax, -0xa4(%rbp)
callq 0x40440
movl -0xa4(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x423cd
movl -0x70(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
| /urbit[P]h2o/deps/libyrmcds/connect.c |
yrmcds_cnt_connect | yrmcds_error yrmcds_cnt_connect(yrmcds_cnt* c, const char* node, uint16_t port) {
if( c == NULL )
return YRMCDS_BAD_ARGUMENT;
#ifndef LIBYRMCDS_NO_INTERNAL_LOCK
int e = pthread_mutex_init(&(c->lock), NULL);
if( e != 0 ) {
errno = e;
return YRMCDS_SYSTEM_ERROR;
}
#endif // ! LIBYRMCDS_NO_INTERNAL_LOCK
int server_fd;
yrmcds_error err = connect_to_server(node, port, &server_fd);
if( err != YRMCDS_OK )
return err;
c->sock = server_fd;
c->serial = 0;
c->recvbuf = (char*)malloc(4096);
if( c->recvbuf == NULL ) {
close(server_fd);
#ifndef LIBYRMCDS_NO_INTERNAL_LOCK
pthread_mutex_destroy(&(c->lock));
#endif
return YRMCDS_OUT_OF_MEMORY;
}
c->capacity = 4096;
c->used = 0;
c->last_size = 0;
c->invalid = 0;
c->stats.count = c->stats.capacity = 0;
c->stats.records = NULL;
return YRMCDS_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4240a
movl $0x2, -0x4(%rbp)
jmp 0x4250a
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3f710
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x4243c
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x40440
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4250a
movq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rdx
movzwl -0x1a(%rbp), %esi
callq 0x42020
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x42461
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4250a
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x68(%rax)
movl $0x1000, %edi # imm = 0x1000
callq 0x40240
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x424b0
movl -0x24(%rbp), %edi
callq 0x3f450
movq -0x10(%rbp), %rdi
callq 0x3f230
movl $0x6, -0x4(%rbp)
jmp 0x4250a
movq -0x10(%rbp), %rax
movq $0x1000, 0x48(%rax) # imm = 0x1000
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x64(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /urbit[P]h2o/deps/libyrmcds/connect.c |
yrmcds_recv | yrmcds_error yrmcds_recv(yrmcds* c, yrmcds_response* r) {
if( c == NULL || r == NULL )
return YRMCDS_BAD_ARGUMENT;
if( c->invalid )
return YRMCDS_PROTOCOL_ERROR;
if( c->last_size > 0 ) {
size_t remain = c->used - c->last_size;
if( remain > 0 )
memmove(c->recvbuf, c->recvbuf + c->last_size, remain);
c->used = remain;
c->last_size = 0;
free(c->decompressed);
c->decompressed = NULL;
}
if( c->text_mode ) {
return text_recv(c, r);
}
while( c->used < BINARY_HEADER_SIZE ) {
yrmcds_error e = recv_data(c);
if( e != 0 ) return e;
}
if( *c->recvbuf != '\x81' ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
uint32_t total_len = ntoh32(c->recvbuf + 8);
if( total_len > MAX_CAPACITY ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
while( c->used < (BINARY_HEADER_SIZE + total_len) ) {
yrmcds_error e = recv_data(c);
if( e != 0 ) return e;
}
uint16_t key_len = ntoh16(c->recvbuf + 2);
uint8_t extras_len = *(unsigned char*)(c->recvbuf + 4);
if( total_len < (key_len + extras_len) ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
const char* pkey = c->recvbuf + (BINARY_HEADER_SIZE + extras_len);
r->length = BINARY_HEADER_SIZE + total_len;
r->command = *(unsigned char*)(c->recvbuf + 1);
r->key = key_len ? pkey : NULL;
r->key_len = key_len;
r->status = ntoh16(c->recvbuf + 6);
memcpy(&(r->serial), c->recvbuf + 12, 4);
r->cas_unique = ntoh64(c->recvbuf + 16);
r->flags = 0;
if( extras_len > 0 ) {
if( extras_len != 4 ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
r->flags = ntoh32(c->recvbuf + BINARY_HEADER_SIZE);
}
size_t data_len = total_len - key_len - extras_len;
const char* pdata = pkey + key_len;
if( (r->command == YRMCDS_CMD_INCREMENT ||
r->command == YRMCDS_CMD_DECREMENT) &&
(r->status == YRMCDS_STATUS_OK) ) {
r->data = NULL;
r->data_len = 0;
if( data_len != 8 ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
r->value = ntoh64(pdata);
c->last_size = r->length;
return YRMCDS_OK;
}
r->value = 0;
r->data = data_len ? pdata : NULL;
r->data_len = data_len;
#ifdef LIBYRMCDS_USE_LZ4
if( c->compress_size && (r->flags & YRMCDS_FLAG_COMPRESS) ) {
if( data_len == 0 ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
r->flags &= ~(uint32_t)YRMCDS_FLAG_COMPRESS;
uint32_t decompress_size = ntoh32(pdata);
if( UINT32_MAX > INT_MAX ) {
if( decompress_size > INT_MAX ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
}
c->decompressed = (char*)malloc(decompress_size);
if( c->decompressed == NULL )
return YRMCDS_OUT_OF_MEMORY;
int d = LZ4_decompress_safe(pdata + sizeof(uint32_t),
c->decompressed,
(int)(data_len - sizeof(uint32_t)),
(int)decompress_size);
if( d != decompress_size ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
r->data = c->decompressed;
r->data_len = decompress_size;
}
#endif // LIBYRMCDS_USE_LZ4
c->last_size = r->length;
return YRMCDS_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4253e
cmpq $0x0, -0x18(%rbp)
jne 0x4254a
movl $0x2, -0x4(%rbp)
jmp 0x42902
movq -0x10(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0x42560
movl $0x8, -0x4(%rbp)
jmp 0x42902
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jbe 0x425d8
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x58(%rcx), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x425a7
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x10(%rbp), %rax
addq 0x58(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3f2d0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x3f330
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
je 0x425f7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x42910
movl %eax, -0x4(%rbp)
jmp 0x42902
jmp 0x425f9
movq -0x10(%rbp), %rax
cmpq $0x18, 0x50(%rax)
jae 0x42623
movq -0x10(%rbp), %rdi
callq 0x43100
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x42621
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x42902
jmp 0x425f9
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $-0x7f, %eax
je 0x4264a
movq -0x10(%rbp), %rax
movl $0x1, 0x68(%rax)
movl $0x8, -0x4(%rbp)
jmp 0x42902
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x8, %rdi
callq 0x431f0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpq $0x3200000, %rax # imm = 0x3200000
jbe 0x42680
movq -0x10(%rbp), %rax
movl $0x1, 0x68(%rax)
movl $0x8, -0x4(%rbp)
jmp 0x42902
jmp 0x42682
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movl -0x28(%rbp), %ecx
addq $0x18, %rcx
cmpq %rcx, %rax
jae 0x426b5
movq -0x10(%rbp), %rdi
callq 0x43100
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x426b3
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x42902
jmp 0x42682
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x2, %rdi
callq 0x43220
movw %ax, -0x2e(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movb 0x4(%rax), %al
movb %al, -0x2f(%rbp)
movl -0x28(%rbp), %eax
movzwl -0x2e(%rbp), %ecx
movzbl -0x2f(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jae 0x42700
movq -0x10(%rbp), %rax
movl $0x1, 0x68(%rax)
movl $0x8, -0x4(%rbp)
jmp 0x42902
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movzbl -0x2f(%rbp), %ecx
addq $0x18, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %ecx
addq $0x18, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movzbl 0x1(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movzwl -0x2e(%rbp), %eax
cmpl $0x0, %eax
je 0x4274e
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x42756
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x42756
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movzwl -0x2e(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x6, %rdi
callq 0x43220
movzwl %ax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x10, %rdi
callq 0x43250
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movzbl -0x2f(%rbp), %eax
cmpl $0x0, %eax
jle 0x42806
movzbl -0x2f(%rbp), %eax
cmpl $0x4, %eax
je 0x427ec
movq -0x10(%rbp), %rax
movl $0x1, 0x68(%rax)
movl $0x8, -0x4(%rbp)
jmp 0x42902
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x18, %rdi
callq 0x431f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x28(%rbp), %eax
movzwl -0x2e(%rbp), %ecx
subl %ecx, %eax
movzbl -0x2f(%rbp), %ecx
subl %ecx, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movzwl -0x2e(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x5, 0x14(%rax)
je 0x42841
movq -0x18(%rbp), %rax
cmpl $0x6, 0x14(%rax)
jne 0x428ae
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x428ae
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
cmpq $0x8, -0x40(%rbp)
je 0x42881
movq -0x10(%rbp), %rax
movl $0x1, 0x68(%rax)
movl $0x8, -0x4(%rbp)
jmp 0x42902
movq -0x48(%rbp), %rdi
callq 0x43250
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x42902
movq -0x18(%rbp), %rax
movq $0x0, 0x48(%rax)
cmpq $0x0, -0x40(%rbp)
je 0x428cb
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x428d3
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x428d3
movq -0x58(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /urbit[P]h2o/deps/libyrmcds/recv.c |
text_recv | static yrmcds_error text_recv(yrmcds* c, yrmcds_response* r) {
char* pos;
while( c->used == 0 ||
(pos = (char*)memchr(c->recvbuf, '\n', c->used)) == NULL ) {
yrmcds_error e = recv_data(c);
if( e != 0 ) return e;
}
// make sure the buffer contains CRLF.
if( (pos - c->recvbuf) < 2 || *(pos-1) != '\r' ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
pos--;
size_t resp_len = (size_t)(pos - c->recvbuf);
memset(r, 0, sizeof(yrmcds_response));
r->serial = ++c->rserial;
r->length = resp_len + 2;
r->status = YRMCDS_STATUS_OK;
r->command = YRMCDS_CMD_BOTTOM; // dummy for emulating binary protocol
if( resp_len == 2 && memcmp(c->recvbuf, "OK", 2) == 0 ) {
// successful response for flush_all
goto FINISH;
}
if( resp_len == 3 && memcmp(c->recvbuf, "END", 3) == 0 ) {
// get failed for non-existing object.
r->status = YRMCDS_STATUS_NOTFOUND;
goto FINISH;
}
if( resp_len == 5 && memcmp(c->recvbuf, "ERROR", 5) == 0 ) {
r->status = YRMCDS_STATUS_UNKNOWNCOMMAND;
goto FINISH;
}
if( resp_len == 6 ) {
if( memcmp(c->recvbuf, "STORED", 6) == 0 ) {
// successful response for storage commands.
goto FINISH;
}
if( memcmp(c->recvbuf, "EXISTS", 6) == 0 ) {
// failure response for cas.
r->status = YRMCDS_STATUS_EXISTS;
goto FINISH;
}
}
if( resp_len == 7 ) {
if( memcmp(c->recvbuf, "DELETED", 7) == 0 )
// successful response for delete.
goto FINISH;
if( memcmp(c->recvbuf, "TOUCHED", 7) == 0 )
// successful response for touch.
goto FINISH;
}
if( resp_len == 9 && memcmp(c->recvbuf, "NOT_FOUND", 9) == 0 ) {
// failure response for cas, delete, incr, decr, or touch.
r->status = YRMCDS_STATUS_NOTFOUND;
goto FINISH;
}
if( resp_len == 10 && memcmp(c->recvbuf, "NOT_STORED", 10) == 0 ) {
// failure response for add, replace, append, or prepend.
r->status = YRMCDS_STATUS_NOTSTORED;
goto FINISH;
}
if( resp_len > 0 && '0' <= c->recvbuf[0] && c->recvbuf[0] <= '9' ) {
// successful response for incr or decr.
const char* p = c->recvbuf;
PARSE_UINT(value);
r->value = value;
goto FINISH;
}
if( resp_len > 8 && memcmp(c->recvbuf, "VERSION ", 8) == 0 ) {
// successful response for version.
r->data_len = resp_len - 8;
r->data = c->recvbuf + 8;
goto FINISH;
}
if( resp_len > 6 && memcmp(c->recvbuf, "VALUE ", 6) == 0 ) {
// successful response for gets.
const char* p = c->recvbuf + 6;
while( *p == ' ' ) p++;
if( p == pos ) goto UNKNOWN;
const char* key_end = memchr(p, ' ', (size_t)(pos - p));
if( key_end == NULL ) goto UNKNOWN;
r->key = p;
r->key_len = (size_t)(key_end - p);
p = key_end;
PARSE_UINT(flags);
if( *p != ' ' ) goto UNKNOWN;
r->flags = (uint32_t)flags;
PARSE_UINT(bytes);
if( bytes > MAX_CAPACITY ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
size_t data_len = (size_t)bytes;
while( *p == ' ' ) p++;
if( *p < '0' || '9' < *p ) goto UNKNOWN;
PARSE_UINT(cas);
size_t required = resp_len + 2 + data_len + 7; // CRLF "END" CRLF
while( c->used < required ) {
yrmcds_error e = recv_data(c);
if( e != 0 ) return e;
}
const char* data = c->recvbuf + (resp_len + 2);
if( memcmp(data + data_len, "\r\nEND\r\n", 7) != 0 ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
r->length = required;
r->flags = (uint32_t)flags;
#ifdef LIBYRMCDS_USE_LZ4
if( c->compress_size && (r->flags & YRMCDS_FLAG_COMPRESS) ) {
if( data_len == 0 ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
r->flags &= ~(uint32_t)YRMCDS_FLAG_COMPRESS;
uint32_t decompress_size = ntoh32(data);
if( UINT32_MAX > INT_MAX ) {
if( decompress_size > INT_MAX ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
}
c->decompressed = (char*)malloc(decompress_size);
if( c->decompressed == NULL )
return YRMCDS_OUT_OF_MEMORY;
int d = LZ4_decompress_safe(data + sizeof(uint32_t),
c->decompressed,
(int)(data_len - sizeof(uint32_t)),
(int)decompress_size);
if( d != decompress_size ) {
c->invalid = 1;
return YRMCDS_PROTOCOL_ERROR;
}
data = c->decompressed;
data_len = (size_t)decompress_size;
}
#endif // LIBYRMCDS_USE_LZ4
r->data = data;
r->data_len = data_len;
r->cas_unique = cas;
goto FINISH;
}
UNKNOWN:
r->status = YRMCDS_STATUS_OTHER;
fprintf(stderr, "[libyrmcds] unknown response: %.*s\n",
(int)resp_len, c->recvbuf);
FINISH:
c->last_size = r->length;
return YRMCDS_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x50(%rcx)
movb %al, -0x89(%rbp)
je 0x42961
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdx
movl $0xa, %esi
callq 0x3f800
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
sete %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x4296d
jmp 0x4298c
movq -0x10(%rbp), %rdi
callq 0x43100
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x4298a
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x430e6
jmp 0x42923
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
cmpq $0x2, %rax
jl 0x429ae
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0xd, %eax
je 0x429c5
movq -0x10(%rbp), %rax
movl $0x1, 0x68(%rax)
movl $0x8, -0x4(%rbp)
jmp 0x430e6
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x3f5b0
movq -0x10(%rbp), %rax
movl 0x70(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x70(%rax)
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rcx
addq $0x2, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x51, 0x14(%rax)
cmpq $0x2, -0x30(%rbp)
jne 0x42a53
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movw (%rax), %ax
subw $0x4b4f, %ax # imm = 0x4B4F
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x42a53
jmp 0x430cf
cmpq $0x3, -0x30(%rbp)
jne 0x42a88
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0x100e59(%rip), %rsi # 0x1438c2
movl $0x3, %edx
callq 0x40720
cmpl $0x0, %eax
jne 0x42a88
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x430cf
cmpq $0x5, -0x30(%rbp)
jne 0x42abd
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0xf69c3(%rip), %rsi # 0x139461
movl $0x5, %edx
callq 0x40720
cmpl $0x0, %eax
jne 0x42abd
movq -0x18(%rbp), %rax
movl $0x81, 0x10(%rax)
jmp 0x430cf
cmpq $0x6, -0x30(%rbp)
jne 0x42b17
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0xf1935(%rip), %rsi # 0x134408
movl $0x6, %edx
callq 0x40720
cmpl $0x0, %eax
jne 0x42ae7
jmp 0x430cf
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0xf18ed(%rip), %rsi # 0x1343e3
movl $0x6, %edx
callq 0x40720
cmpl $0x0, %eax
jne 0x42b15
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x430cf
jmp 0x42b17
cmpq $0x7, -0x30(%rbp)
jne 0x42b66
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0xf18bd(%rip), %rsi # 0x1343ea
movl $0x7, %edx
callq 0x40720
cmpl $0x0, %eax
jne 0x42b41
jmp 0x430cf
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0xf18a2(%rip), %rsi # 0x1343f2
movl $0x7, %edx
callq 0x40720
cmpl $0x0, %eax
jne 0x42b64
jmp 0x430cf
jmp 0x42b66
cmpq $0x9, -0x30(%rbp)
jne 0x42b9b
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0xf187e(%rip), %rsi # 0x1343fa
movl $0x9, %edx
callq 0x40720
cmpl $0x0, %eax
jne 0x42b9b
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x430cf
cmpq $0xa, -0x30(%rbp)
jne 0x42bd0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0xf1853(%rip), %rsi # 0x134404
movl $0xa, %edx
callq 0x40720
cmpl $0x0, %eax
jne 0x42bd0
movq -0x18(%rbp), %rax
movl $0x5, 0x10(%rax)
jmp 0x430cf
cmpq $0x0, -0x30(%rbp)
jbe 0x42caa
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x42caa
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x42caa
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x42c35
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x42c1b
jmp 0x42c37
movq -0x38(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x8a(%rbp)
jg 0x42c62
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x8a(%rbp)
movb -0x8a(%rbp), %al
testb $0x1, %al
jne 0x42c6e
jmp 0x42c99
imulq $0xa, -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cltq
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x42c37
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
jmp 0x430cf
cmpq $0x8, -0x30(%rbp)
jbe 0x42cfd
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rax
movabsq $0x204e4f4953524556, %rcx # imm = 0x204E4F4953524556
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x42cfd
movq -0x30(%rbp), %rcx
subq $0x8, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x8, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x430cf
cmpq $0x6, -0x30(%rbp)
jbe 0x4309c
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0xf1701(%rip), %rsi # 0x134418
movl $0x6, %edx
callq 0x40720
cmpl $0x0, %eax
jne 0x4309c
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
addq $0x6, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x42d54
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x42d3a
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x42d63
jmp 0x4309e
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x3f800
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x42d8c
jmp 0x4309e
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x42dd5
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x42dbb
jmp 0x42dd7
movq -0x48(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x8b(%rbp)
jg 0x42e02
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x8b(%rbp)
movb -0x8b(%rbp), %al
testb $0x1, %al
jne 0x42e0e
jmp 0x42e39
imulq $0xa, -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cltq
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x42dd7
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x42e4a
jmp 0x4309e
movq -0x58(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq $0x0, -0x60(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x42e79
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x42e5f
jmp 0x42e7b
movq -0x48(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x8c(%rbp)
jg 0x42ea6
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x8c(%rbp)
movb -0x8c(%rbp), %al
testb $0x1, %al
jne 0x42eb2
jmp 0x42edd
imulq $0xa, -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cltq
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x42e7b
cmpq $0x3200000, -0x60(%rbp) # imm = 0x3200000
jbe 0x42efe
movq -0x10(%rbp), %rax
movl $0x1, 0x68(%rax)
movl $0x8, -0x4(%rbp)
jmp 0x430e6
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x42f20
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x42f06
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x42f3c
movq -0x48(%rbp), %rax
movsbl (%rax), %ecx
movl $0x39, %eax
cmpl %ecx, %eax
jge 0x42f41
jmp 0x4309e
movq $0x0, -0x70(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x42f63
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x42f49
jmp 0x42f65
movq -0x48(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x8d(%rbp)
jg 0x42f90
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x8d(%rbp)
movb -0x8d(%rbp), %al
testb $0x1, %al
jne 0x42f9c
jmp 0x42fc7
imulq $0xa, -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cltq
addq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x42f65
movq -0x30(%rbp), %rax
addq $0x2, %rax
addq -0x68(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
cmpq -0x78(%rbp), %rax
jae 0x43008
movq -0x10(%rbp), %rdi
callq 0x43100
movl %eax, -0x7c(%rbp)
cmpl $0x0, -0x7c(%rbp)
je 0x43006
movl -0x7c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x430e6
jmp 0x42fdb
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x30(%rbp), %rcx
addq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
addq -0x68(%rbp), %rdi
leaq 0xf13eb(%rip), %rsi # 0x13441f
movl $0x7, %edx
callq 0x40720
cmpl $0x0, %eax
je 0x4305a
movq -0x10(%rbp), %rax
movl $0x1, 0x68(%rax)
movl $0x8, -0x4(%rbp)
jmp 0x430e6
movq -0x78(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x88(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x68(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x70(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x430cf
jmp 0x4309e
movq -0x18(%rbp), %rax
movl $0xffff, 0x10(%rax) # imm = 0xFFFF
movq 0x1a8f08(%rip), %rax # 0x1ebfb8
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
leaq 0xf135f(%rip), %rsi # 0x134427
movb $0x0, %al
callq 0x3f380
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/deps/libyrmcds/recv.c |
yrmcds_strerror | const char* yrmcds_strerror(yrmcds_error e) {
switch( e ) {
case YRMCDS_OK:
return "OK";
case YRMCDS_SYSTEM_ERROR:
return "Check errno for details";
case YRMCDS_BAD_ARGUMENT:
return "Bad argument";
case YRMCDS_NOT_RESOLVED:
return "Host not found";
case YRMCDS_TIMEOUT:
return "Timeout";
case YRMCDS_DISCONNECTED:
return "Connection was reset by peer";
case YRMCDS_OUT_OF_MEMORY:
return "Failed to allocate memory";
case YRMCDS_COMPRESS_FAILED:
return "Failed to compress data";
case YRMCDS_PROTOCOL_ERROR:
return "Received malformed packet";
case YRMCDS_NOT_IMPLEMENTED:
return "Not implemented";
case YRMCDS_IN_BINARY:
return "Connection is fixed for binary protocol";
case YRMCDS_BAD_KEY:
return "Bad key";
default:
return "Unknown error";
};
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xb, %rax
ja 0x46211
movq -0x18(%rbp), %rax
leaq 0xee33d(%rip), %rcx # 0x1344a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xee26d(%rip), %rax # 0x1343e0
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee34d(%rip), %rax # 0x1344d0
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee355(%rip), %rax # 0x1344e8
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee352(%rip), %rax # 0x1344f5
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee354(%rip), %rax # 0x134504
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee34f(%rip), %rax # 0x13450c
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee35f(%rip), %rax # 0x134529
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee36c(%rip), %rax # 0x134543
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee377(%rip), %rax # 0x13455b
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee384(%rip), %rax # 0x134575
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee387(%rip), %rax # 0x134585
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee3a2(%rip), %rax # 0x1345ad
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xee39d(%rip), %rax # 0x1345b5
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /urbit[P]h2o/deps/libyrmcds/strerror.c |
erase_ref | static void erase_ref(h2o_cache_t *cache, khiter_t iter, int reuse)
{
h2o_cache_ref_t *ref = kh_key(cache->table, iter);
if (!reuse)
kh_del(cache, cache->table, iter);
h2o_linklist_unlink(&ref->_lru_link);
h2o_linklist_unlink(&ref->_age_link);
cache->size -= ref->value.len;
h2o_cache_release(cache, ref);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x47f1f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x48b90
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x483d0
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0x483d0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x484a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/cache.c |
h2o_cache_fetch | h2o_cache_ref_t *h2o_cache_fetch(h2o_cache_t *cache, uint64_t now, h2o_iovec_t key, h2o_cache_hashcode_t keyhash)
{
h2o_cache_ref_t search_key, *ref;
khiter_t iter;
int64_t timeleft;
if (keyhash == 0)
keyhash = h2o_cache_calchash(key.base, key.len);
search_key.key = key;
search_key.keyhash = keyhash;
lock_cache(cache);
purge(cache, now);
if ((iter = kh_get(cache, cache->table, &search_key)) == kh_end(cache->table))
goto NotFound;
/* found */
ref = kh_key(cache->table, iter);
timeleft = get_timeleft(cache, ref, now);
if (timeleft < 0)
goto NotFound;
if ((cache->flags & H2O_CACHE_FLAG_EARLY_UPDATE) != 0 && timeleft < 10 && !ref->_requested_early_update) {
ref->_requested_early_update = 1;
goto NotFound;
}
/* move the entry to the top of LRU */
h2o_linklist_unlink(&ref->_lru_link);
h2o_linklist_insert(&cache->lru, &ref->_lru_link);
__sync_fetch_and_add(&ref->_refcnt, 1);
/* unlock and return the found entry */
unlock_cache(cache);
return ref;
NotFound:
unlock_cache(cache);
return NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x48145
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x47b50
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x80(%rbp)
movq -0x20(%rbp), %rdi
callq 0x47e90
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x48290
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x90(%rbp), %rsi
callq 0x47f70
movl %eax, -0x9c(%rbp)
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jne 0x481a2
jmp 0x48265
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movl -0x9c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x483a0
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jge 0x481e6
jmp 0x48265
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4821b
cmpq $0xa, -0xa8(%rbp)
jge 0x4821b
movq -0x98(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x4821b
movq -0x98(%rbp), %rax
movl $0x1, 0x30(%rax)
jmp 0x48265
movq -0x98(%rbp), %rdi
addq $0x38, %rdi
callq 0x483d0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x98(%rbp), %rsi
addq $0x38, %rsi
callq 0x48420
movq -0x98(%rbp), %rax
lock
incq 0x58(%rax)
movq -0x20(%rbp), %rdi
callq 0x480e0
movq -0x98(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x48276
movq -0x20(%rbp), %rdi
callq 0x480e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/cache.c |
purge | static void purge(h2o_cache_t *cache, uint64_t now)
{
/* by cache size */
while (cache->capacity < cache->size) {
h2o_cache_ref_t *last;
assert(!h2o_linklist_is_empty(&cache->lru));
last = H2O_STRUCT_FROM_MEMBER(h2o_cache_ref_t, _lru_link, cache->lru.next);
erase_ref(cache, kh_get(cache, cache->table, last), 0);
}
/* by TTL */
while (!h2o_linklist_is_empty(&cache->age)) {
h2o_cache_ref_t *oldest = H2O_STRUCT_FROM_MEMBER(h2o_cache_ref_t, _age_link, cache->age.next);
if (get_timeleft(cache, oldest, now) >= 0)
break;
erase_ref(cache, kh_get(cache, cache->table, oldest), 0);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x4831d
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x47ec0
cmpl $0x0, %eax
jne 0x482c6
jmp 0x482e5
leaq 0xec6e6(%rip), %rdi # 0x1349b3
leaq 0xec548(%rip), %rsi # 0x13481c
movl $0x5c, %edx
leaq 0xec6f7(%rip), %rcx # 0x1349d7
callq 0x3f2e0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $-0x38, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x47f70
movq -0x28(%rbp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x47ee0
jmp 0x482a0
jmp 0x4831f
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x47ec0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4833a
jmp 0x4838b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
addq $-0x48, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x483a0
cmpq $0x0, %rax
jl 0x48363
jmp 0x4838b
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x47f70
movq -0x30(%rbp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x47ee0
jmp 0x4831f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/cache.c |
h2o_cache_release | void h2o_cache_release(h2o_cache_t *cache, h2o_cache_ref_t *ref)
{
if (__sync_fetch_and_sub(&ref->_refcnt, 1) == 1) {
assert(!h2o_linklist_is_linked(&ref->_lru_link));
assert(!h2o_linklist_is_linked(&ref->_age_link));
if (cache->destroy_cb != NULL)
cache->destroy_cb(ref->value);
free(ref->key.base);
free(ref);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x58, %rax
lock
decq (%rax)
sete %al
testb $0x1, %al
je 0x48563
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x480c0
cmpl $0x0, %eax
jne 0x484db
jmp 0x484fa
leaq 0xec3e0(%rip), %rdi # 0x1348c2
leaq 0xec333(%rip), %rsi # 0x13481c
movl $0xc7, %edx
leaq 0xec3f6(%rip), %rcx # 0x1348eb
callq 0x3f2e0
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x480c0
cmpl $0x0, %eax
jne 0x4850e
jmp 0x4852d
leaq 0xec40f(%rip), %rdi # 0x134924
leaq 0xec300(%rip), %rsi # 0x13481c
movl $0xc8, %edx
leaq 0xec3c3(%rip), %rcx # 0x1348eb
callq 0x3f2e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x4854e
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq 0x28(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3f330
movq -0x10(%rbp), %rdi
callq 0x3f330
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /urbit[P]h2o/lib/common/cache.c |
h2o_cache_set | int h2o_cache_set(h2o_cache_t *cache, uint64_t now, h2o_iovec_t key, h2o_cache_hashcode_t keyhash, h2o_iovec_t value)
{
h2o_cache_ref_t *newref;
khiter_t iter;
int existed;
if (keyhash == 0)
keyhash = h2o_cache_calchash(key.base, key.len);
/* create newref */
newref = h2o_mem_alloc(sizeof(*newref));
*newref = (h2o_cache_ref_t){h2o_strdup(NULL, key.base, key.len), keyhash, now, value, 0, {NULL}, {NULL}, 1};
lock_cache(cache);
/* set or replace the named value */
iter = kh_get(cache, cache->table, newref);
if (iter != kh_end(cache->table)) {
erase_ref(cache, iter, 1);
kh_key(cache->table, iter) = newref;
existed = 1;
} else {
int unused;
kh_put(cache, cache->table, newref, &unused);
existed = 0;
}
h2o_linklist_insert(&cache->lru, &newref->_lru_link);
h2o_linklist_insert(&cache->age, &newref->_age_link);
cache->size += newref->value.len;
purge(cache, now);
unlock_cache(cache);
return existed;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x485b0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x47b50
movl %eax, -0x24(%rbp)
movl $0x60, %edi
callq 0x47c60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x56620
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0x98(%rbp)
movq %rdx, -0x90(%rbp)
movl -0x24(%rbp), %ecx
movl %ecx, -0x88(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movq (%rax), %rcx
movq %rcx, -0x78(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x1, -0x40(%rbp)
leaq -0x98(%rbp), %rsi
movl $0x60, %edx
callq 0x3f180
movq -0x18(%rbp), %rdi
callq 0x47e90
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x47f70
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
je 0x486b6
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %esi
movl $0x1, %edx
callq 0x47ee0
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movl -0x34(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl $0x1, -0x38(%rbp)
jmp 0x486d5
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x9c(%rbp), %rdx
callq 0x48740
movl $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x30(%rbp), %rsi
addq $0x38, %rsi
callq 0x48420
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movq -0x30(%rbp), %rsi
addq $0x48, %rsi
callq 0x48420
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x48290
movq -0x18(%rbp), %rdi
callq 0x480e0
movl -0x38(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/cache.c |
h2o_cache_delete | void h2o_cache_delete(h2o_cache_t *cache, uint64_t now, h2o_iovec_t key, h2o_cache_hashcode_t keyhash)
{
h2o_cache_ref_t search_key;
khiter_t iter;
if (keyhash == 0)
keyhash = h2o_cache_calchash(key.base, key.len);
search_key.key = key;
search_key.keyhash = keyhash;
lock_cache(cache);
purge(cache, now);
if ((iter = kh_get(cache, cache->table, &search_key)) != kh_end(cache->table))
erase_ref(cache, iter, 0);
unlock_cache(cache);
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x48ad5
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x47b50
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x47e90
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x48290
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x88(%rbp), %rsi
callq 0x47f70
movl %eax, -0x8c(%rbp)
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
je 0x48b3b
movq -0x18(%rbp), %rdi
movl -0x8c(%rbp), %esi
xorl %edx, %edx
callq 0x47ee0
movq -0x18(%rbp), %rdi
callq 0x480e0
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
| /urbit[P]h2o/lib/common/cache.c |
h2o_filecache_clear | void h2o_filecache_clear(h2o_filecache_t *cache)
{
khiter_t iter;
for (iter = kh_begin(cache->hash); iter != kh_end(cache->hash); ++iter) {
if (!kh_exist(cache->hash, iter))
continue;
release_from_cache(cache, iter);
}
assert(kh_size(cache->hash) == 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x493d2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0xc(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x493bb
jmp 0x493c7
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x49480
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x49383
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x493e1
jmp 0x49400
leaq 0xeb6c8(%rip), %rdi # 0x134ab0
leaq 0xeb6db(%rip), %rsi # 0x134aca
movl $0x50, %edx
leaq 0xeb757(%rip), %rcx # 0x134b52
callq 0x3f2e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/filecache.c |
release_from_cache | static inline void release_from_cache(h2o_filecache_t *cache, khiter_t iter)
{
const char *path = kh_key(cache->hash, iter);
h2o_filecache_ref_t *ref = H2O_STRUCT_FROM_MEMBER(h2o_filecache_ref_t, _path, path);
/* detach from list */
kh_del(opencache_set, cache->hash, iter);
h2o_linklist_unlink(&ref->_lru);
/* and close */
h2o_filecache_close_file(ref);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $-0x130, %rax # imm = 0xFED0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x49ec0
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x49f40
movq -0x20(%rbp), %rdi
callq 0x49c60
addq $0x20, %rsp
popq %rbp
retq
nop
| /urbit[P]h2o/lib/common/filecache.c |
h2o_filecache_open_file | h2o_filecache_ref_t *h2o_filecache_open_file(h2o_filecache_t *cache, const char *path, int oflag)
{
khiter_t iter = kh_get(opencache_set, cache->hash, path);
h2o_filecache_ref_t *ref;
int dummy;
/* lookup cache, and return the one if found */
if (iter != kh_end(cache->hash)) {
ref = H2O_STRUCT_FROM_MEMBER(h2o_filecache_ref_t, _path, kh_key(cache->hash, iter));
++ref->_refcnt;
goto Exit;
}
/* create a new cache entry */
ref = h2o_mem_alloc(offsetof(h2o_filecache_ref_t, _path) + strlen(path) + 1);
ref->_refcnt = 1;
ref->_lru = (h2o_linklist_t){NULL};
strcpy(ref->_path, path);
/* if cache is used, then... */
if (cache->capacity != 0) {
/* purge one entry from LRU if cache is full */
if (kh_size(cache->hash) == cache->capacity) {
h2o_filecache_ref_t *purge_ref = H2O_STRUCT_FROM_MEMBER(h2o_filecache_ref_t, _lru, cache->lru.prev);
khiter_t purge_iter = kh_get(opencache_set, cache->hash, purge_ref->_path);
assert(purge_iter != kh_end(cache->hash));
release_from_cache(cache, purge_iter);
}
/* assign the new entry */
++ref->_refcnt;
kh_put(opencache_set, cache->hash, ref->_path, &dummy);
h2o_linklist_insert(cache->lru.next, &ref->_lru);
}
/* open the file, or memoize the error */
if ((ref->fd = open(path, oflag)) != -1 && fstat(ref->fd, &ref->st) == 0) {
ref->_last_modified.str[0] = '\0';
ref->_etag.len = 0;
} else {
ref->open_err = errno;
if (ref->fd != -1) {
close(ref->fd);
ref->fd = -1;
}
}
Exit:
/* if the cache entry retains an error, return it instead of the reference */
if (ref->fd == -1) {
errno = ref->open_err;
h2o_filecache_close_file(ref);
ref = NULL;
}
return ref;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x49730
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x49545
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
addq $-0x130, %rax # imm = 0xFED0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x496ee
movq -0x10(%rbp), %rdi
callq 0x3f780
movq %rax, %rdi
addq $0x130, %rdi # imm = 0x130
addq $0x1, %rdi
callq 0x49250
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
addq $0x130, %rdi # imm = 0x130
movq -0x10(%rbp), %rsi
callq 0x3f790
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x49671
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x49631
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
addq $0x130, %rsi # imm = 0x130
callq 0x49730
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x49606
jmp 0x49625
leaq 0xeb571(%rip), %rdi # 0x134b7e
leaq 0xeb4b6(%rip), %rsi # 0x134aca
movl $0x6c, %edx
leaq 0xeb580(%rip), %rcx # 0x134ba0
callq 0x3f2e0
movq -0x8(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x49480
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x130, %rsi # imm = 0x130
leaq -0x24(%rbp), %rdx
callq 0x49880
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x49be0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movb $0x0, %al
callq 0x3f880
movq -0x20(%rbp), %rcx
movl %eax, (%rcx)
cmpl $-0x1, %eax
je 0x496be
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
callq 0x401b0
cmpl $0x0, %eax
jne 0x496be
movq -0x20(%rbp), %rax
movb $0x0, 0xe8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x128(%rax)
jmp 0x496ec
callq 0x40440
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x496ea
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x3f450
movq -0x20(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
jmp 0x496ec
jmp 0x496ee
movq -0x20(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x4971c
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x48(%rbp)
callq 0x40440
movl -0x48(%rbp), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x49c60
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/filecache.c |
h2o_filecache_close_file | void h2o_filecache_close_file(h2o_filecache_ref_t *ref)
{
if (--ref->_refcnt != 0)
return;
assert(!h2o_linklist_is_linked(&ref->_lru));
if (ref->fd != -1) {
close(ref->fd);
ref->fd = -1;
}
free(ref);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
je 0x49c84
jmp 0x49cde
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x49cf0
cmpl $0x0, %eax
jne 0x49c98
jmp 0x49cb7
leaq 0xeaf54(%rip), %rdi # 0x134bf3
leaq 0xeae24(%rip), %rsi # 0x134aca
movl $0x8f, %edx
leaq 0xeaf65(%rip), %rcx # 0x134c17
callq 0x3f2e0
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x49cd5
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x3f450
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x3f330
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/filecache.c |
h2o_filecache_get_last_modified | struct tm *h2o_filecache_get_last_modified(h2o_filecache_ref_t *ref, char *outbuf)
{
assert(ref->fd != -1);
if (ref->_last_modified.str[0] == '\0') {
gmtime_r(&ref->st.st_mtime, &ref->_last_modified.gm);
h2o_time2str_rfc1123(ref->_last_modified.str, &ref->_last_modified.gm);
}
if (outbuf != NULL)
memcpy(outbuf, ref->_last_modified.str, H2O_TIMESTR_RFC1123_LEN + 1);
return &ref->_last_modified.gm;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x49d2b
jmp 0x49d4a
leaq 0xeaf1a(%rip), %rdi # 0x134c4c
leaq 0xead91(%rip), %rsi # 0x134aca
movl $0x99, %edx
leaq 0xeaf15(%rip), %rcx # 0x134c5a
callq 0x3f2e0
movq -0x8(%rbp), %rax
movsbl 0xe8(%rax), %eax
cmpl $0x0, %eax
jne 0x49da1
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
addq $0x58, %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
addq $0x90, %rsi
callq 0x3fef0
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
addq $0x90, %rdi
addq $0x38, %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
addq $0x90, %rsi
callq 0x58140
cmpq $0x0, -0x10(%rbp)
je 0x49de4
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0xe8(%rcx), %rdx
movq %rdx, (%rax)
movq 0xf0(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0xf8(%rcx), %rdx
movq %rdx, 0x10(%rax)
movl 0x100(%rcx), %edx
movl %edx, 0x18(%rax)
movw 0x104(%rcx), %cx
movw %cx, 0x1c(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rax
addq $0x90, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /urbit[P]h2o/lib/common/filecache.c |
h2o_hostinfo_getaddr | h2o_hostinfo_getaddr_req_t *h2o_hostinfo_getaddr(h2o_multithread_receiver_t *receiver, h2o_iovec_t name, h2o_iovec_t serv,
int family, int socktype, int protocol, int flags, h2o_hostinfo_getaddr_cb cb,
void *cbdata)
{
h2o_hostinfo_getaddr_req_t *req = h2o_mem_alloc(sizeof(*req) + name.len + 1 + serv.len + 1);
req->_receiver = receiver;
req->_cb = cb;
req->cbdata = cbdata;
req->_pending = (h2o_linklist_t){NULL};
req->_in.name = (char *)req + sizeof(*req);
memcpy(req->_in.name, name.base, name.len);
req->_in.name[name.len] = '\0';
req->_in.serv = req->_in.name + name.len + 1;
memcpy(req->_in.serv, serv.base, serv.len);
req->_in.serv[serv.len] = '\0';
memset(&req->_in.hints, 0, sizeof(req->_in.hints));
req->_in.hints.ai_family = family;
req->_in.hints.ai_socktype = socktype;
req->_in.hints.ai_protocol = protocol;
req->_in.hints.ai_flags = flags;
h2o__hostinfo_getaddr_dispatch(req);
return req;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
addq $0x1, %rdi
addq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x4a540
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq 0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq $0x0, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rcx
addq $0x68, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x3f180
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rcx
addq -0x8(%rbp), %rcx
addq $0x1, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3f180
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x3f5b0
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x3c(%rax)
movl 0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x40(%rax)
movl 0x18(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x44(%rax)
movl 0x20(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x38(%rbp), %rdi
callq 0x4a580
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /urbit[P]h2o/lib/common/hostinfo.c |
h2o_hostinfo_getaddr_receiver | void h2o_hostinfo_getaddr_receiver(h2o_multithread_receiver_t *receiver, h2o_linklist_t *messages)
{
while (!h2o_linklist_is_empty(messages)) {
h2o_hostinfo_getaddr_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_hostinfo_getaddr_req_t, _out.message.link, messages->next);
h2o_linklist_unlink(&req->_out.message.link);
h2o_hostinfo_getaddr_cb cb = req->_cb;
if (cb != NULL) {
req->_cb = NULL;
cb(req, req->_out.errstr, req->_out.ai, req->cbdata);
}
if (req->_out.ai != NULL)
freeaddrinfo(req->_out.ai);
free(req);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4a8f0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4a85a
jmp 0x4a8dd
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $-0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x4a7e0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4a8b7
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rsi
movq -0x18(%rbp), %rcx
movq 0x40(%rcx), %rdx
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
callq *%rax
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x4a8cf
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3fc80
movq -0x18(%rbp), %rdi
callq 0x3f330
jmp 0x4a840
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/hostinfo.c |
fetch_aton_digit | static const char *fetch_aton_digit(const char *p, const char *end, unsigned char *value)
{
size_t ndigits = 0;
int v = 0;
while (p != end && ('0' <= *p && *p <= '9')) {
v = v * 10 + *p++ - '0';
++ndigits;
}
if (!(1 <= ndigits && ndigits <= 3))
return NULL;
if (v > 255)
return NULL;
*value = (unsigned char)v;
return p;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x2d(%rbp)
je 0x4aa39
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x2e(%rbp)
jg 0x4aa33
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x4aa42
jmp 0x4aa6e
imull $0xa, -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4a9ff
movl $0x1, %eax
cmpq -0x28(%rbp), %rax
ja 0x4aa80
cmpq $0x3, -0x28(%rbp)
jbe 0x4aa8a
movq $0x0, -0x8(%rbp)
jmp 0x4aab0
cmpl $0xff, -0x2c(%rbp)
jle 0x4aa9d
movq $0x0, -0x8(%rbp)
jmp 0x4aab0
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/hostinfo.c |
lookup_thread_main | static void *lookup_thread_main(void *_unused)
{
pthread_mutex_lock(&queue.mutex);
while (1) {
--queue.num_threads_idle;
while (!h2o_linklist_is_empty(&queue.pending)) {
h2o_hostinfo_getaddr_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_hostinfo_getaddr_req_t, _pending, queue.pending.next);
h2o_linklist_unlink(&req->_pending);
pthread_mutex_unlock(&queue.mutex);
lookup_and_respond(req);
pthread_mutex_lock(&queue.mutex);
}
++queue.num_threads_idle;
pthread_cond_wait(&queue.cond, &queue.mutex);
}
h2o_fatal("unreachable");
return NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1a229d(%rip), %rdi # 0x1ecd70
callq 0x3f4f0
movq 0x1a2301(%rip), %rax # 0x1ecde0
addq $-0x1, %rax
movq %rax, 0x1a22f6(%rip) # 0x1ecde0
leaq 0x1a227f(%rip), %rdi # 0x1ecd70
addq $0x58, %rdi
callq 0x4a8f0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4ab08
jmp 0x4ab47
movq 0x1a22b9(%rip), %rax # 0x1ecdc8
addq $-0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x4a7e0
leaq 0x1a2245(%rip), %rdi # 0x1ecd70
callq 0x3f4a0
movq -0x10(%rbp), %rdi
callq 0x4ab80
leaq 0x1a2230(%rip), %rdi # 0x1ecd70
callq 0x3f4f0
jmp 0x4aaea
movq 0x1a2292(%rip), %rax # 0x1ecde0
addq $0x1, %rax
movq %rax, 0x1a2287(%rip) # 0x1ecde0
leaq 0x1a2210(%rip), %rsi # 0x1ecd70
movq %rsi, %rdi
addq $0x28, %rdi
callq 0x3fa10
jmp 0x4aad8
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/hostinfo.c |
create_client | static struct st_h2o_http1client_private_t *create_client(h2o_http1client_t **_client, void *data, h2o_http1client_ctx_t *ctx,
h2o_iovec_t ssl_server_name, h2o_http1client_connect_cb cb)
{
struct st_h2o_http1client_private_t *client = h2o_mem_alloc(sizeof(*client));
*client = (struct st_h2o_http1client_private_t){{ctx}};
if (ssl_server_name.base != NULL)
client->super.ssl.server_name = h2o_strdup(NULL, ssl_server_name.base, ssl_server_name.len).base;
client->super.data = data;
client->_cb.on_connect = cb;
/* caller needs to setup _cb, timeout.cb, sock, and sock->data */
if (_client != NULL)
*_client = &client->super;
return client;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x90, %edi
callq 0x4b450
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x3f5b0
movq -0xe0(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xc8(%rbp), %rsi
movl $0x90, %edx
callq 0x3f180
cmpq $0x0, -0x10(%rbp)
je 0x4af27
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x56620
movq %rax, -0xd8(%rbp)
movq %rdx, -0xd0(%rbp)
movq -0xd8(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x4af51
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nop
| /urbit[P]h2o/lib/common/http1client.c |
on_handshake_complete | static void on_handshake_complete(h2o_socket_t *sock, const char *err)
{
struct st_h2o_http1client_private_t *client = sock->data;
h2o_timeout_unlink(&client->_timeout);
if (err == NULL) {
/* success */
} else if (err == h2o_socket_error_ssl_cert_name_mismatch &&
(SSL_CTX_get_verify_mode(client->super.ctx->ssl_ctx) & SSL_VERIFY_PEER) == 0) {
/* peer verification skipped */
} else {
on_connect_error(client, err);
return;
}
on_connection_ready(client);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x58bf0
cmpq $0x0, -0x10(%rbp)
jne 0x4b561
jmp 0x4b59c
movq -0x10(%rbp), %rax
leaq 0x1a28bc(%rip), %rcx # 0x1ede28
cmpq (%rcx), %rax
jne 0x4b58b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
callq 0x403c0
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4b58b
jmp 0x4b59a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4b030
jmp 0x4b5a5
jmp 0x4b59c
movq -0x18(%rbp), %rdi
callq 0x4b5b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /urbit[P]h2o/lib/common/http1client.c |
on_send_request | static void on_send_request(h2o_socket_t *sock, const char *err)
{
struct st_h2o_http1client_private_t *client = sock->data;
h2o_timeout_unlink(&client->_timeout);
if (err != NULL) {
on_error_before_head(client, "I/O error (send request)");
return;
}
h2o_socket_read_start(client->super.sock, on_head);
client->_timeout.cb = on_head_timeout;
h2o_timeout_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->_timeout);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x58bf0
cmpq $0x0, -0x10(%rbp)
je 0x4b691
movq -0x18(%rbp), %rdi
leaq 0xe96da(%rip), %rsi # 0x134d64
callq 0x4b710
jmp 0x4b6d6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x130(%rip), %rsi # 0x4b7d0
callq 0x51ff0
movq -0x18(%rbp), %rax
leaq 0x970(%rip), %rcx # 0x4c020
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
addq $0x40, %rdx
callq 0x58af0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /urbit[P]h2o/lib/common/http1client.c |
on_head | static void on_head(h2o_socket_t *sock, const char *err)
{
struct st_h2o_http1client_private_t *client = sock->data;
int minor_version, http_status, rlen, is_eos;
const char *msg;
#define MAX_HEADERS 100
h2o_header_t *headers;
h2o_iovec_t *header_names;
size_t msg_len, num_headers, i;
h2o_socket_cb reader;
h2o_mem_pool_t pool;
h2o_timeout_unlink(&client->_timeout);
if (err != NULL) {
on_error_before_head(client, "I/O error (head)");
return;
}
h2o_mem_init_pool(&pool);
headers = h2o_mem_alloc_pool(&pool, sizeof(*headers) * MAX_HEADERS);
header_names = h2o_mem_alloc_pool(&pool, sizeof(*header_names) * MAX_HEADERS);
/* continue parsing the responses until we see a final one */
while (1) {
/* parse response */
struct phr_header src_headers[MAX_HEADERS];
num_headers = MAX_HEADERS;
rlen = phr_parse_response(sock->input->bytes, sock->input->size, &minor_version, &http_status, &msg, &msg_len, src_headers,
&num_headers, 0);
switch (rlen) {
case -1: /* error */
on_error_before_head(client, "failed to parse the response");
goto Exit;
case -2: /* incomplete */
h2o_timeout_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->_timeout);
goto Exit;
}
/* fill-in the headers */
for (i = 0; i != num_headers; ++i) {
const h2o_token_t *token;
char *orig_name = h2o_strdup(&pool, src_headers[i].name, src_headers[i].name_len).base;
h2o_strtolower((char *)src_headers[i].name, src_headers[i].name_len);
token = h2o_lookup_token(src_headers[i].name, src_headers[i].name_len);
if (token != NULL) {
headers[i].name = (h2o_iovec_t *)&token->buf;
} else {
header_names[i] = h2o_iovec_init(src_headers[i].name, src_headers[i].name_len);
headers[i].name = &header_names[i];
}
headers[i].value = h2o_iovec_init(src_headers[i].value, src_headers[i].value_len);
headers[i].orig_name = orig_name;
}
if (!(100 <= http_status && http_status <= 199 && http_status != 101))
break;
if (client->super.informational_cb != NULL &&
client->super.informational_cb(&client->super, minor_version, http_status, h2o_iovec_init(msg, msg_len), headers,
num_headers) != 0) {
close_client(client);
goto Exit;
}
h2o_buffer_consume(&client->super.sock->input, rlen);
if (client->super.sock->input->size == 0) {
h2o_timeout_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->_timeout);
goto Exit;
}
}
/* parse the headers */
reader = on_body_until_close;
client->_can_keepalive = minor_version >= 1;
for (i = 0; i != num_headers; ++i) {
if (headers[i].name == &H2O_TOKEN_CONNECTION->buf) {
if (h2o_contains_token(headers[i].value.base, headers[i].value.len, H2O_STRLIT("keep-alive"), ',')) {
client->_can_keepalive = 1;
} else {
client->_can_keepalive = 0;
}
} else if (headers[i].name == &H2O_TOKEN_TRANSFER_ENCODING->buf) {
if (h2o_memis(headers[i].value.base, headers[i].value.len, H2O_STRLIT("chunked"))) {
/* precond: _body_decoder.chunked is zero-filled */
client->_body_decoder.chunked.decoder.consume_trailer = 1;
reader = on_body_chunked;
} else if (h2o_memis(headers[i].value.base, headers[i].value.len, H2O_STRLIT("identity"))) {
/* continue */
} else {
on_error_before_head(client, "unexpected type of transfer-encoding");
goto Exit;
}
} else if (headers[i].name == &H2O_TOKEN_CONTENT_LENGTH->buf) {
if ((client->_body_decoder.content_length.bytesleft = h2o_strtosize(headers[i].value.base, headers[i].value.len)) ==
SIZE_MAX) {
on_error_before_head(client, "invalid content-length");
goto Exit;
}
if (reader != on_body_chunked)
reader = on_body_content_length;
}
}
/* RFC 2616 4.4 */
if (client->_method_is_head || http_status == 101 || http_status == 204 || http_status == 304) {
is_eos = 1;
} else {
is_eos = 0;
/* close the connection if impossible to determine the end of the response (RFC 7230 3.3.3) */
if (reader == on_body_until_close)
client->_can_keepalive = 0;
}
/* call the callback. sock may be stealed and stealed sock need rlen.*/
client->_cb.on_body = client->_cb.on_head(&client->super, is_eos ? h2o_http1client_error_is_eos : NULL, minor_version,
http_status, h2o_iovec_init(msg, msg_len), headers, num_headers, rlen);
if (is_eos) {
close_client(client);
goto Exit;
} else if (client->_cb.on_body == NULL) {
client->_can_keepalive = 0;
close_client(client);
goto Exit;
}
h2o_buffer_consume(&client->super.sock->input, rlen);
client->super.sock->bytes_read = client->super.sock->input->size;
client->_timeout.cb = on_body_timeout;
h2o_socket_read_start(sock, reader);
reader(client->super.sock, 0);
Exit:
h2o_mem_clear_pool(&pool);
#undef MAX_HEADERS
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xde8, %rsp # imm = 0xDE8
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x58bf0
cmpq $0x0, -0x18(%rbp)
je 0x4b818
movq -0x20(%rbp), %rdi
leaq 0xe9632(%rip), %rsi # 0x134e40
callq 0x4b710
jmp 0x4c00c
leaq -0x88(%rbp), %rdi
callq 0x4dbb0
leaq -0x88(%rbp), %rdi
movl $0xc80, %esi # imm = 0xC80
callq 0x4dd50
movq %rax, -0x40(%rbp)
leaq -0x88(%rbp), %rdi
movl $0x640, %esi # imm = 0x640
callq 0x4dd50
movq %rax, -0x48(%rbp)
movq $0x64, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdi
movq %rsp, %rax
leaq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
leaq -0xd10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x10(%rax)
leaq -0x24(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x38(%rbp), %r8
leaq -0x50(%rbp), %r9
callq 0x46940
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0xd74(%rbp)
subl $-0x2, %eax
je 0x4b8cd
jmp 0x4b8ab
movl -0xd74(%rbp), %eax
subl $-0x1, %eax
jne 0x4b8f4
jmp 0x4b8b8
movq -0x20(%rbp), %rdi
leaq 0xe958e(%rip), %rsi # 0x134e51
callq 0x4b710
jmp 0x4c000
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
addq $0x40, %rdx
callq 0x58af0
jmp 0x4c000
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0x4bb20
movq -0x60(%rbp), %rcx
leaq -0xd10(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x60(%rbp), %rcx
leaq -0xd10(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
leaq -0x88(%rbp), %rdi
callq 0x56620
movq %rax, -0xd30(%rbp)
movq %rdx, -0xd28(%rbp)
movq -0xd30(%rbp), %rax
movq %rax, -0xd20(%rbp)
movq -0x60(%rbp), %rcx
leaq -0xd10(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x60(%rbp), %rcx
leaq -0xd10(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x4c050
movq -0x60(%rbp), %rcx
leaq -0xd10(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x60(%rbp), %rcx
leaq -0xd10(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x6c910
movq %rax, -0xd18(%rbp)
cmpq $0x0, -0xd18(%rbp)
je 0x4b9ec
movq -0xd18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x4ba80
movq -0x48(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0xd80(%rbp)
movq -0x60(%rbp), %rcx
leaq -0xd10(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x60(%rbp), %rcx
leaq -0xd10(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x4af60
movq %rax, %rcx
movq -0xd80(%rbp), %rax
movq %rcx, -0xd40(%rbp)
movq %rdx, -0xd38(%rbp)
movq -0xd40(%rbp), %rcx
movq %rcx, (%rax)
movq -0xd38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq -0x60(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0xd88(%rbp)
movq -0x60(%rbp), %rcx
leaq -0xd10(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq -0x60(%rbp), %rcx
leaq -0xd10(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
callq 0x4af60
movq %rax, %rcx
movq -0xd88(%rbp), %rax
movq %rcx, -0xd50(%rbp)
movq %rdx, -0xd48(%rbp)
movq -0xd50(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0xd48(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0xd20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x4b8fc
movl $0x64, %eax
cmpl -0x28(%rbp), %eax
jg 0x4bb39
cmpl $0xc7, -0x28(%rbp)
jg 0x4bb39
cmpl $0x65, -0x28(%rbp)
jne 0x4bb3e
jmp 0x4bc37
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x4bbe3
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0xd98(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xda8(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0xd9c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0xd8c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x4af60
movq -0xda8(%rbp), %rdi
movl -0xd9c(%rbp), %esi
movq %rax, %r8
movq -0xd98(%rbp), %rax
movq %rdx, %rcx
movl -0xd8c(%rbp), %edx
movq %r8, -0xd60(%rbp)
movq %rcx, -0xd58(%rbp)
movq -0x40(%rbp), %r9
movq -0x58(%rbp), %r10
movq -0xd60(%rbp), %rcx
movq -0xd58(%rbp), %r8
movq %r10, (%rsp)
callq *%rax
cmpl $0x0, %eax
je 0x4bbe3
movq -0x20(%rbp), %rdi
callq 0x4b300
jmp 0x4c000
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x10, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x4e500
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4bc32
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
addq $0x40, %rdx
callq 0x58af0
jmp 0x4c000
jmp 0x4b84e
leaq 0x462(%rip), %rax # 0x4c0a0
movq %rax, -0x68(%rbp)
cmpl $0x1, -0x24(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x70(%rax)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0x4be61
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
leaq 0x1a21ef(%rip), %rcx # 0x1ede70
addq $0x180, %rcx # imm = 0x180
cmpq %rcx, (%rax)
jne 0x4bcec
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
leaq 0xe91b4(%rip), %rdx # 0x134e6e
movl $0xa, %ecx
movl $0x2c, %r8d
callq 0x57b00
cmpl $0x0, %eax
je 0x4bcdc
movq -0x20(%rbp), %rax
movl $0x1, 0x70(%rax)
jmp 0x4bce7
movq -0x20(%rbp), %rax
movl $0x0, 0x70(%rax)
jmp 0x4be4e
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
leaq 0x1a216e(%rip), %rcx # 0x1ede70
addq $0x4e0, %rcx # imm = 0x4E0
cmpq %rcx, (%rax)
jne 0x4bdc0
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
leaq 0xe913a(%rip), %rdx # 0x134e79
movl $0x7, %ecx
callq 0x4c150
cmpl $0x0, %eax
je 0x4bd66
movq -0x20(%rbp), %rax
movb $0x1, 0x80(%rax)
leaq 0x490(%rip), %rax # 0x4c1f0
movq %rax, -0x68(%rbp)
jmp 0x4bdbb
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
leaq 0xe90ee(%rip), %rdx # 0x134e81
movl $0x8, %ecx
callq 0x4c150
cmpl $0x0, %eax
je 0x4bda4
jmp 0x4bdb9
movq -0x20(%rbp), %rdi
leaq 0xe90db(%rip), %rsi # 0x134e8a
callq 0x4b710
jmp 0x4c000
jmp 0x4bdbb
jmp 0x4be4c
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
leaq 0x1a209a(%rip), %rcx # 0x1ede70
addq $0x1e0, %rcx # imm = 0x1E0
cmpq %rcx, (%rax)
jne 0x4be4a
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
callq 0x56960
movq -0x20(%rbp), %rcx
movq %rax, 0x78(%rcx)
cmpq $-0x1, %rax
jne 0x4be30
movq -0x20(%rbp), %rdi
leaq 0xe9089(%rip), %rsi # 0x134eaf
callq 0x4b710
jmp 0x4c000
leaq 0x3b9(%rip), %rax # 0x4c1f0
cmpq %rax, -0x68(%rbp)
je 0x4be48
leaq 0x58c(%rip), %rax # 0x4c3d0
movq %rax, -0x68(%rbp)
jmp 0x4be4a
jmp 0x4be4c
jmp 0x4be4e
jmp 0x4be50
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x4bc5d
movq -0x20(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x4be83
cmpl $0x65, -0x28(%rbp)
je 0x4be83
cmpl $0xcc, -0x28(%rbp)
je 0x4be83
cmpl $0x130, -0x28(%rbp) # imm = 0x130
jne 0x4be8c
movl $0x1, -0x30(%rbp)
jmp 0x4bead
movl $0x0, -0x30(%rbp)
leaq 0x206(%rip), %rax # 0x4c0a0
cmpq %rax, -0x68(%rbp)
jne 0x4beab
movq -0x20(%rbp), %rax
movl $0x0, 0x70(%rax)
jmp 0x4bead
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0xdb8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xdd0(%rbp)
movl -0x30(%rbp), %edx
xorl %eax, %eax
leaq 0xf8b4e(%rip), %rcx # 0x144a21
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0xdc8(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0xdac(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0xdbc(%rbp)
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x4af60
movq -0xdd0(%rbp), %rdi
movq -0xdc8(%rbp), %rsi
movl -0xdbc(%rbp), %ecx
movq %rax, %r9
movq -0xdb8(%rbp), %rax
movq %rdx, %r8
movl -0xdac(%rbp), %edx
movq %r9, -0xd70(%rbp)
movq %r8, -0xd68(%rbp)
movq -0x40(%rbp), %rbx
movq -0x58(%rbp), %r11
movl -0x2c(%rbp), %r10d
movq -0xd70(%rbp), %r8
movq -0xd68(%rbp), %r9
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
cmpl $0x0, -0x30(%rbp)
je 0x4bf7e
movq -0x20(%rbp), %rdi
callq 0x4b300
jmp 0x4c000
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x4bf9f
movq -0x20(%rbp), %rax
movl $0x0, 0x70(%rax)
movq -0x20(%rbp), %rdi
callq 0x4b300
jmp 0x4c000
jmp 0x4bfa1
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x10, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x4e500
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
leaq 0x563(%rip), %rcx # 0x4c540
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x51ff0
movq -0x68(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
leaq -0x88(%rbp), %rdi
callq 0x4dbf0
addq $0xde8, %rsp # imm = 0xDE8
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/http1client.c |
on_body_until_close | static void on_body_until_close(h2o_socket_t *sock, const char *err)
{
struct st_h2o_http1client_private_t *client = sock->data;
h2o_timeout_unlink(&client->_timeout);
if (err != NULL) {
client->_cb.on_body(&client->super, h2o_http1client_error_is_eos);
close_client(client);
return;
}
if (sock->bytes_read != 0) {
if (client->_cb.on_body(&client->super, NULL) != 0) {
close_client(client);
return;
}
}
h2o_timeout_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->_timeout);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x58bf0
cmpq $0x0, -0x10(%rbp)
je 0x4c0ef
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rdi
leaq 0xf893f(%rip), %rsi # 0x144a21
callq *%rax
movq -0x18(%rbp), %rdi
callq 0x4b300
jmp 0x4c140
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4c11e
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
cmpl $0x0, %eax
je 0x4c11c
movq -0x18(%rbp), %rdi
callq 0x4b300
jmp 0x4c140
jmp 0x4c11e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
addq $0x40, %rdx
callq 0x58af0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/common/http1client.c |
h2o_memis | inline int h2o_memis(const void *_target, size_t target_len, const void *_test, size_t test_len)
{
const char *target = (const char *)_target, *test = (const char *)_test;
if (target_len != test_len)
return 0;
if (target_len == 0)
return 1;
if (target[0] != test[0])
return 0;
return memcmp(target + 1, test + 1, test_len - 1) == 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x5f73b
movl $0x0, -0x4(%rbp)
jmp 0x5f791
cmpq $0x0, -0x18(%rbp)
jne 0x5f74b
movl $0x1, -0x4(%rbp)
jmp 0x5f791
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
movq -0x38(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x5f766
movl $0x0, -0x4(%rbp)
jmp 0x5f791
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
movq -0x38(%rbp), %rsi
addq $0x1, %rsi
movq -0x28(%rbp), %rdx
subq $0x1, %rdx
callq 0x40720
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /urbit[P]h2o/include/h2o/memory.h |
append_unsafe_string_json | static char *append_unsafe_string_json(char *pos, const char *src, size_t len)
{
const char *src_end = src + len;
for (; src != src_end; ++src) {
if (' ' <= *src && *src < 0x7e) {
if (*src == '"' || *src == '\\')
*pos++ = '\\';
*pos++ = *src;
} else {
*pos++ = '\\';
*pos++ = 'u';
*pos++ = '0';
*pos++ = '0';
*pos++ = ("0123456789abcdef")[(*src >> 4) & 0xf];
*pos++ = ("0123456789abcdef")[*src & 0xf];
}
}
return pos;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x6646a
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x20, %eax
cmpl %ecx, %eax
jg 0x663bc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jge 0x663bc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x6638e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x663a0
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x5c, (%rax)
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x66457
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x5c, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x75, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x30, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x30, (%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
sarl $0x4, %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0xd0709(%rip), %rax # 0x136b24
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0xd06e1(%rip), %rax # 0x136b24
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x66459
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6634c
movq -0x8(%rbp), %rax
popq %rbp
retq
| /urbit[P]h2o/lib/core/logconf.c |
h2o_url_hosts_are_equal | static inline int h2o_url_hosts_are_equal(const h2o_url_t *url_a, const h2o_url_t *url_b)
{
if (url_a->host.len != url_b->host.len)
return 0;
if (h2o_url_host_is_unix_path(url_a->host))
return h2o_memis(url_a->host.base, url_a->host.len, url_b->host.base, url_b->host.len);
else
return h2o_lcstris(url_a->host.base, url_a->host.len, url_b->host.base, url_b->host.len);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x6996b
movl $0x0, -0x4(%rbp)
jmp 0x699d3
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
callq 0x69a20
cmpl $0x0, %eax
je 0x699ab
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
callq 0x686c0
movl %eax, -0x4(%rbp)
jmp 0x699d3
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
callq 0x674f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /urbit[P]h2o/include/h2o/url.h |
append_chunk | __attribute__((format(printf, 3, 4))) static void append_chunk(h2o_mem_pool_t *pool, h2o_iovec_vector_t *chunks, const char *fmt,
...)
{
va_list args;
va_start(args, fmt);
int size = vsnprintf(NULL, 0, fmt, args);
va_end(args);
assert(size > 0);
h2o_iovec_t v;
v.base = h2o_mem_alloc_pool(pool, size + 1);
va_start(args, fmt);
v.len = vsnprintf(v.base, size + 1, fmt, args);
va_end(args);
h2o_vector_reserve(pool, chunks, chunks->size + 1);
chunks->entries[chunks->size++] = v;
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
testb %al, %al
je 0x96c9e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x3fcb0
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
cmpl $0x0, -0x34(%rbp)
jle 0x96d06
jmp 0x96d25
leaq 0xabaa6(%rip), %rdi # 0x1427b3
leaq 0xabaa8(%rip), %rsi # 0x1427bc
movl $0x4a, %edx
leaq 0xabafd(%rip), %rcx # 0x14281d
callq 0x3f2e0
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %eax
incl %eax
movslq %eax, %rsi
callq 0x4dd50
movq %rax, -0x48(%rbp)
leaq -0x100(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movq -0x48(%rbp), %rdi
movl -0x34(%rbp), %eax
incl %eax
movslq %eax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x3fcb0
cltq
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x8(%rsi), %rcx
incq %rcx
movl $0x10, %edx
callq 0x96f70
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
incq %rsi
movq %rsi, 0x8(%rdx)
shlq $0x4, %rcx
movups -0x48(%rbp), %xmm0
movups %xmm0, (%rax,%rcx)
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
nopl (%rax)
| /urbit[P]h2o/lib/http2/http2_debug_state.c |
append_header_table_chunks | static void append_header_table_chunks(h2o_mem_pool_t *pool, h2o_iovec_vector_t *chunks, h2o_hpack_header_table_t *header_table)
{
int i;
for (i = 0; i < header_table->num_entries; i++) {
h2o_hpack_header_table_entry_t *entry = h2o_hpack_header_table_get(header_table, i);
append_chunk(pool, chunks, "\n"
" [ \"%.*s\", \"%.*s\" ],",
(int)entry->name->len, entry->name->base, (int)entry->value->len, entry->value->base);
}
if (i > 0) {
// remove the last commna
--chunks->entries[chunks->size - 1].len;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x96f30
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x96fe0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %r8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movl %eax, %r9d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
leaq 0xab977(%rip), %rdx # 0x142891
movq %rax, (%rsp)
movb $0x0, %al
callq 0x96c60
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x96ebb
cmpl $0x0, -0x1c(%rbp)
jle 0x96f5c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/lib/http2/http2_debug_state.c |
yaml_string_extend | YAML_DECLARE(int)
yaml_string_extend(yaml_char_t **start,
yaml_char_t **pointer, yaml_char_t **end)
{
yaml_char_t *new_start = yaml_realloc(*start, (*end - *start)*2);
if (!new_start) return 0;
memset(new_start + (*end - *start), 0, *end - *start);
*pointer = new_start + (*pointer - *start);
*end = new_start + (*end - *start)*2;
*start = new_start;
return 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rsi
shlq %rsi
callq 0x970e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9722b
movl $0x0, -0x4(%rbp)
jmp 0x972ae
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x3f5b0
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
shlq %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /urbit[P]h2o/deps/yaml/src/api.c |
yaml_string_join | YAML_DECLARE(int)
yaml_string_join(
yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end)
{
if (*b_start == *b_pointer)
return 1;
while (*a_end - *a_pointer <= *b_pointer - *b_start) {
if (!yaml_string_extend(a_start, a_pointer, a_end))
return 0;
}
memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
*a_pointer += *b_pointer - *b_start;
return 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x972fc
movl $0x1, -0x4(%rbp)
jmp 0x9738c
jmp 0x972fe
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jg 0x97346
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x971e0
cmpl $0x0, %eax
jne 0x97344
movl $0x0, -0x4(%rbp)
jmp 0x9738c
jmp 0x972fe
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rax
subq %rax, %rdx
callq 0x3f180
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/deps/yaml/src/api.c |
yaml_queue_extend | YAML_DECLARE(int)
yaml_queue_extend(void **start, void **head, void **tail, void **end)
{
/* Check if we need to resize the queue. */
if (*start == *head && *tail == *end) {
void *new_start = yaml_realloc(*start,
((char *)*end - (char *)*start)*2);
if (!new_start) return 0;
*head = (char *)new_start + ((char *)*head - (char *)*start);
*tail = (char *)new_start + ((char *)*tail - (char *)*start);
*end = (char *)new_start + ((char *)*end - (char *)*start)*2;
*start = new_start;
}
/* Check if we need to move the queue at the beginning of the buffer. */
if (*tail == *end) {
if (*head != *tail) {
memmove(*start, *head, (char *)*tail - (char *)*head);
}
*tail = (char *)*tail - (char *)*head + (char *)*start;
*head = *start;
}
return 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x97532
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x97532
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rsi
shlq %rsi
callq 0x970e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x974c7
movl $0x0, -0x4(%rbp)
jmp 0x975aa
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
shlq %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x975a3
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
je 0x97576
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
subq %rax, %rdx
callq 0x3f2d0
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/deps/yaml/src/api.c |
yaml_parser_scan_directive_name | static int
yaml_parser_scan_directive_name(yaml_parser_t *parser,
yaml_mark_t start_mark, yaml_char_t **name)
{
yaml_string_t string = NULL_STRING;
if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
/* Consume the directive name. */
if (!CACHE(parser, 1)) goto error;
while (IS_ALPHA(parser->buffer))
{
if (!READ(parser, string)) goto error;
if (!CACHE(parser, 1)) goto error;
}
/* Check if the name is empty. */
if (string.start == string.pointer) {
yaml_parser_set_scanner_error(parser, "while scanning a directive",
start_mark, "could not find expected directive name");
goto error;
}
/* Check for an blank character after the name. */
if (!IS_BLANKZ(parser->buffer)) {
yaml_parser_set_scanner_error(parser, "while scanning a directive",
start_mark, "found unexpected non-alphabetical character");
goto error;
}
*name = string.start;
return 1;
error:
STRING_DEL(parser, string);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
movl $0x10, %edi
callq 0x970a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xb2e28
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3f5b0
movb $0x1, %al
testb $0x1, %al
jne 0xb2e3d
jmp 0xb2e38
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb2e3d
jmp 0xb3416
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb2e53
movb $0x1, %al
testb $0x1, %al
jne 0xb2e6b
jmp 0xb2e66
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb2e6b
jmp 0xb3416
jmp 0xb2e6d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0xb2e9c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x39, %ecx
movb %al, -0x39(%rbp)
jle 0xb2f21
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x41, %eax
jl 0xb2ec7
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x5a, %ecx
movb %al, -0x39(%rbp)
jle 0xb2f21
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x61, %eax
jl 0xb2ef2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x7a, %ecx
movb %al, -0x39(%rbp)
jle 0xb2f21
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x5f, %ecx
movb %al, -0x39(%rbp)
je 0xb2f21
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xb2f2d
jmp 0xb3265
movq -0x20(%rbp), %rax
addq $0x5, %rax
cmpq -0x28(%rbp), %rax
jb 0xb2f59
leaq -0x30(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x10, %rsi
leaq -0x30(%rbp), %rdx
addq $0x8, %rdx
callq 0x971e0
cmpl $0x0, %eax
je 0xb2f64
movb $0x1, %al
testb $0x1, %al
jne 0xb2f79
jmp 0xb3225
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb2f79
jmp 0xb3225
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb2fc5
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
jmp 0xb31db
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb3042
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0x40(%rbp)
jmp 0xb31d8
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb30ef
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0x44(%rbp)
jmp 0xb31d2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0xb31c5
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0x48(%rbp)
jmp 0xb31cc
xorl %eax, %eax
movl %eax, -0x48(%rbp)
jmp 0xb31cc
movl -0x48(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movb $0x1, %al
testb $0x1, %al
jne 0xb3232
jmp 0xb322d
xorl %eax, %eax
testb $0x1, %al
jne 0xb3232
jmp 0xb322d
jmp 0xb3416
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb3248
movb $0x1, %al
testb $0x1, %al
jne 0xb3260
jmp 0xb325b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb3260
jmp 0xb3416
jmp 0xb2e6d
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xb32a8
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
leaq 0x91271(%rip), %rsi # 0x1444ef
leaq 0x912cd(%rip), %rdx # 0x144552
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb1fa0
jmp 0xb3416
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0xb3402
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
je 0xb3402
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0xb3402
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xb3402
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xb3333
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x85, %eax
je 0xb3402
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb3378
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb3378
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa8, %eax
je 0xb3402
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb33b9
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb33b9
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa9, %eax
je 0xb3402
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0xb3402
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
leaq 0x91114(%rip), %rsi # 0x1444ef
leaq 0x91197(%rip), %rdx # 0x144579
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb1fa0
jmp 0xb3416
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xb343e
movq -0x30(%rbp), %rdi
callq 0x97170
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_save_simple_key | static int
yaml_parser_save_simple_key(yaml_parser_t *parser)
{
/*
* A simple key is required at the current position if the scanner is in
* the block context and the current column coincides with the indentation
* level.
*/
int required = (!parser->flow_level
&& parser->indent == (ptrdiff_t)parser->mark.column);
/*
* A simple key is required only when it is the first token in the current
* line. Therefore it is always allowed. But we add a check anyway.
*/
assert(parser->simple_key_allowed || !required); /* Impossible. */
/*
* If the current position may start a simple key, save it.
*/
if (parser->simple_key_allowed)
{
yaml_simple_key_t simple_key;
simple_key.possible = 1;
simple_key.required = required;
simple_key.token_number =
parser->tokens_parsed + (parser->tokens.tail - parser->tokens.head);
simple_key.mark = parser->mark;
if (!yaml_parser_remove_simple_key(parser)) return 0;
*(parser->simple_keys.top-1) = simple_key;
}
return 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x100(%rcx)
movb %al, -0x41(%rbp)
jne 0xb5d1a
movq -0x10(%rbp), %rax
movslq 0x150(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xf0(%rcx), %rax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x154(%rax)
jne 0xb5d38
cmpl $0x0, -0x14(%rbp)
jne 0xb5d3a
jmp 0xb5d59
leaq 0x8ea96(%rip), %rdi # 0x1447d7
leaq 0x8e690(%rip), %rsi # 0x1443d8
movl $0x459, %edx # imm = 0x459
leaq 0x8eaab(%rip), %rcx # 0x1447ff
callq 0x3f2e0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x154(%rax)
je 0xb5e10
movl $0x1, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x118(%rcx), %rcx
subq %rcx, %rax
movl $0x50, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0xe8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0xf0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb2020
cmpl $0x0, %eax
jne 0xb5df3
movl $0x0, -0x4(%rbp)
jmp 0xb5e17
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rdi
addq $-0x28, %rdi
leaq -0x40(%rbp), %rsi
movl $0x28, %edx
callq 0x3f180
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
| /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_roll_indent | static int
yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column,
ptrdiff_t number, yaml_token_type_t type, yaml_mark_t mark)
{
yaml_token_t token;
/* In the flow context, do nothing. */
if (parser->flow_level)
return 1;
if (parser->indent < column)
{
/*
* Push the current indentation level to the stack and set the new
* indentation level.
*/
if (!PUSH(parser, parser->indents, parser->indent))
return 0;
if (column > INT_MAX) {
parser->error = YAML_MEMORY_ERROR;
return 0;
}
parser->indent = column;
/* Create a token and insert it into the queue. */
TOKEN_INIT(token, type, mark, mark);
if (number == -1) {
if (!ENQUEUE(parser, parser->tokens, token))
return 0;
}
else {
if (!QUEUE_INSERT(parser,
parser->tokens, number - parser->tokens_parsed, token))
return 0;
}
}
return 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x100(%rax)
je 0xb5fbb
movl $0x1, -0x4(%rbp)
jmp 0xb62e4
movq -0x10(%rbp), %rax
movslq 0x150(%rax), %rax
cmpq -0x18(%rbp), %rax
jge 0xb62dd
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x140(%rcx), %rax
jne 0xb601b
movq -0x10(%rbp), %rdi
addq $0x138, %rdi # imm = 0x138
movq -0x10(%rbp), %rsi
addq $0x138, %rsi # imm = 0x138
addq $0x10, %rsi
movq -0x10(%rbp), %rdx
addq $0x138, %rdx # imm = 0x138
addq $0x8, %rdx
callq 0x973a0
cmpl $0x0, %eax
je 0xb6048
movq -0x10(%rbp), %rax
movl 0x150(%rax), %ecx
movq -0x10(%rbp), %rdx
movq 0x148(%rdx), %rax
movq %rax, %rsi
addq $0x4, %rsi
movq %rsi, 0x148(%rdx)
movl %ecx, (%rax)
movb $0x1, %al
testb $0x1, %al
jne 0xb6064
jmp 0xb6058
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb6064
movl $0x0, -0x4(%rbp)
jmp 0xb62e4
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jle 0xb6084
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xb62e4
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x150(%rax)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x3f5b0
movq -0x80(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, -0x78(%rbp)
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0xb6191
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xb6141
movq -0x10(%rbp), %rdi
addq $0x108, %rdi # imm = 0x108
movq -0x10(%rbp), %rsi
addq $0x108, %rsi # imm = 0x108
addq $0x10, %rsi
movq -0x10(%rbp), %rdx
addq $0x108, %rdx # imm = 0x108
addq $0x18, %rdx
movq -0x10(%rbp), %rcx
addq $0x108, %rcx # imm = 0x108
addq $0x8, %rcx
callq 0x97450
cmpl $0x0, %eax
je 0xb6170
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rdi
movq %rdi, %rcx
addq $0x50, %rcx
movq %rcx, 0x120(%rax)
leaq -0x78(%rbp), %rsi
movl $0x50, %edx
callq 0x3f180
movb $0x1, %al
testb $0x1, %al
jne 0xb618c
jmp 0xb6180
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb618c
movl $0x0, -0x4(%rbp)
jmp 0xb62e4
jmp 0xb62db
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xb61ef
movq -0x10(%rbp), %rdi
addq $0x108, %rdi # imm = 0x108
movq -0x10(%rbp), %rsi
addq $0x108, %rsi # imm = 0x108
addq $0x10, %rsi
movq -0x10(%rbp), %rdx
addq $0x108, %rdx # imm = 0x108
addq $0x18, %rdx
movq -0x10(%rbp), %rcx
addq $0x108, %rcx # imm = 0x108
addq $0x8, %rcx
callq 0x97450
cmpl $0x0, %eax
je 0xb62c0
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq 0x128(%rcx), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rsi
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq 0x128(%rcx), %rax
imulq $0x50, %rax, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x118(%rcx), %rcx
subq %rcx, %rax
movl $0x50, %ecx
cqto
idivq %rcx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq 0x128(%rdx), %rcx
subq %rcx, %rax
imulq $0x50, %rax, %rdx
callq 0x3f2d0
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq 0x128(%rcx), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq -0x78(%rbp), %rsi
movl $0x50, %edx
callq 0x3f180
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rcx
addq $0x50, %rcx
movq %rcx, 0x120(%rax)
movb $0x1, %al
testb $0x1, %al
jne 0xb62d9
jmp 0xb62d0
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb62d9
movl $0x0, -0x4(%rbp)
jmp 0xb62e4
jmp 0xb62db
jmp 0xb62dd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
| /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_scan_anchor | static int
yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token,
yaml_token_type_t type)
{
int length = 0;
yaml_mark_t start_mark, end_mark;
yaml_string_t string = NULL_STRING;
if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
/* Eat the indicator character. */
start_mark = parser->mark;
SKIP(parser);
/* Consume the value. */
if (!CACHE(parser, 1)) goto error;
while (IS_ALPHA(parser->buffer)) {
if (!READ(parser, string)) goto error;
if (!CACHE(parser, 1)) goto error;
length ++;
}
end_mark = parser->mark;
/*
* Check if length of the anchor is greater than 0 and it is followed by
* a whitespace character or one of the indicators:
*
* '?', ':', ',', ']', '}', '%', '@', '`'.
*/
if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')
|| CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',')
|| CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}')
|| CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@')
|| CHECK(parser->buffer, '`'))) {
yaml_parser_set_scanner_error(parser, type == YAML_ANCHOR_TOKEN ?
"while scanning an anchor" : "while scanning an alias", start_mark,
"did not find expected alphabetic or numeric character");
goto error;
}
/* Create a token. */
if (type == YAML_ANCHOR_TOKEN) {
ANCHOR_TOKEN_INIT(*token, string.start, start_mark, end_mark);
}
else {
ALIAS_TOKEN_INIT(*token, string.start, start_mark, end_mark);
}
return 1;
error:
STRING_DEL(parser, string);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
movl $0x10, %edi
callq 0x970a0
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0xb635d
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x68(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3f5b0
movb $0x1, %al
testb $0x1, %al
jne 0xb6372
jmp 0xb636d
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb6372
jmp 0xb6be9
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0xe8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0xf0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb63fb
movl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0xb6476
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb641f
movl $0x2, %eax
movl %eax, -0x70(%rbp)
jmp 0xb6470
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb6443
movl $0x3, %eax
movl %eax, -0x74(%rbp)
jmp 0xb646a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb64a7
movb $0x1, %al
testb $0x1, %al
jne 0xb64bf
jmp 0xb64ba
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb64bf
jmp 0xb6be9
jmp 0xb64c1
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0xb64f0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x39, %ecx
movb %al, -0x75(%rbp)
jle 0xb6575
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x41, %eax
jl 0xb651b
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x5a, %ecx
movb %al, -0x75(%rbp)
jle 0xb6575
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x61, %eax
jl 0xb6546
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x7a, %ecx
movb %al, -0x75(%rbp)
jle 0xb6575
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x5f, %ecx
movb %al, -0x75(%rbp)
je 0xb6575
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x75(%rbp)
movb -0x75(%rbp), %al
testb $0x1, %al
jne 0xb6581
jmp 0xb68cb
movq -0x58(%rbp), %rax
addq $0x5, %rax
cmpq -0x60(%rbp), %rax
jb 0xb65ad
leaq -0x68(%rbp), %rdi
leaq -0x68(%rbp), %rsi
addq $0x10, %rsi
leaq -0x68(%rbp), %rdx
addq $0x8, %rdx
callq 0x971e0
cmpl $0x0, %eax
je 0xb65b8
movb $0x1, %al
testb $0x1, %al
jne 0xb65cd
jmp 0xb6882
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb65cd
jmp 0xb6882
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb6619
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
jmp 0xb6838
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb6696
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0x7c(%rbp)
jmp 0xb6835
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb6743
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0x80(%rbp)
jmp 0xb682f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0xb681c
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0x84(%rbp)
jmp 0xb6826
xorl %eax, %eax
movl %eax, -0x84(%rbp)
jmp 0xb6826
movl -0x84(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movb $0x1, %al
testb $0x1, %al
jne 0xb688f
jmp 0xb688a
xorl %eax, %eax
testb $0x1, %al
jne 0xb688f
jmp 0xb688a
jmp 0xb6be9
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb68a5
movb $0x1, %al
testb $0x1, %al
jne 0xb68bd
jmp 0xb68b8
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb68bd
jmp 0xb6be9
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb64c1
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0xe8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0xf0(%rax), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xb6ad2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xb6985
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x85, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb69ca
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb69ca
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa8, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb6a0f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb6a0f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa9, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x3f, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x3a, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2c, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x5d, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x7d, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x25, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x40, %eax
je 0xb6b1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x60, %eax
je 0xb6b1c
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %ecx
leaq 0x8ddfc(%rip), %rsi # 0x1448dc
leaq 0x8dddc(%rip), %rax # 0x1448c3
cmpl $0x13, %ecx
cmoveq %rax, %rsi
leaq -0x38(%rbp), %rax
leaq 0x8ddfb(%rip), %rdx # 0x1448f4
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb1fa0
jmp 0xb6be9
cmpl $0x13, -0x1c(%rbp)
jne 0xb6b82
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x3f5b0
movq -0x18(%rbp), %rax
movl $0x13, (%rax)
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x68(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xb6be0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x3f5b0
movq -0x18(%rbp), %rax
movl $0x12, (%rax)
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x68(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xb6c11
movq -0x68(%rbp), %rdi
callq 0x97170
movq $0x0, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x68(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
| /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_scan_tag | static int
yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)
{
yaml_char_t *handle = NULL;
yaml_char_t *suffix = NULL;
yaml_mark_t start_mark, end_mark;
start_mark = parser->mark;
/* Check if the tag is in the canonical form. */
if (!CACHE(parser, 2)) goto error;
if (CHECK_AT(parser->buffer, '<', 1))
{
/* Set the handle to '' */
handle = yaml_malloc(1);
if (!handle) goto error;
handle[0] = '\0';
/* Eat '!<' */
SKIP(parser);
SKIP(parser);
/* Consume the tag value. */
if (!yaml_parser_scan_tag_uri(parser, 0, NULL, start_mark, &suffix))
goto error;
/* Check for '>' and eat it. */
if (!CHECK(parser->buffer, '>')) {
yaml_parser_set_scanner_error(parser, "while scanning a tag",
start_mark, "did not find the expected '>'");
goto error;
}
SKIP(parser);
}
else
{
/* The tag has either the '!suffix' or the '!handle!suffix' form. */
/* First, try to scan a handle. */
if (!yaml_parser_scan_tag_handle(parser, 0, start_mark, &handle))
goto error;
/* Check if it is, indeed, handle. */
if (handle[0] == '!' && handle[1] != '\0' && handle[strlen((char *)handle)-1] == '!')
{
/* Scan the suffix now. */
if (!yaml_parser_scan_tag_uri(parser, 0, NULL, start_mark, &suffix))
goto error;
}
else
{
/* It wasn't a handle after all. Scan the rest of the tag. */
if (!yaml_parser_scan_tag_uri(parser, 0, handle, start_mark, &suffix))
goto error;
/* Set the handle to '!'. */
yaml_free(handle);
handle = yaml_malloc(2);
if (!handle) goto error;
handle[0] = '!';
handle[1] = '\0';
/*
* A special case: the '!' tag. Set the handle to '' and the
* suffix to '!'.
*/
if (suffix[0] == '\0') {
yaml_char_t *tmp = handle;
handle = suffix;
suffix = tmp;
}
}
}
/* Check the character which ends the tag. */
if (!CACHE(parser, 1)) goto error;
if (!IS_BLANKZ(parser->buffer)) {
yaml_parser_set_scanner_error(parser, "while scanning a tag",
start_mark, "did not find expected whitespace or line break");
goto error;
}
end_mark = parser->mark;
/* Create a token. */
TAG_TOKEN_INIT(*token, handle, suffix, start_mark, end_mark);
return 1;
error:
yaml_free(handle);
yaml_free(suffix);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0xe8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0xf0(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x2, 0xa8(%rax)
jb 0xb6c7e
movb $0x1, %al
testb $0x1, %al
jne 0xb6c96
jmp 0xb6c91
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb6c96
jmp 0xb73c4
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x3c, %eax
jne 0xb7054
movl $0x1, %edi
callq 0x970a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb6cc8
jmp 0xb73c4
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb6d33
movl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0xb6dae
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb6d57
movl $0x2, %eax
movl %eax, -0x68(%rbp)
jmp 0xb6da8
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb6d7b
movl $0x3, %eax
movl %eax, -0x6c(%rbp)
jmp 0xb6da2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb6e2d
movl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0xb6ea8
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb6e51
movl $0x2, %eax
movl %eax, -0x74(%rbp)
jmp 0xb6ea2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb6e75
movl $0x3, %eax
movl %eax, -0x78(%rbp)
jmp 0xb6e9c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
leaq -0x40(%rbp), %rax
leaq -0x28(%rbp), %rcx
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb4c70
cmpl $0x0, %eax
jne 0xb6efd
jmp 0xb73c4
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x3e, %eax
je 0xb6f49
movq -0x10(%rbp), %rdi
leaq 0x8d7b0(%rip), %rsi # 0x1446cb
leaq -0x40(%rbp), %rax
leaq 0x8da04(%rip), %rdx # 0x14492a
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb1fa0
jmp 0xb73c4
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb6fb0
movl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0xb7034
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb6fd4
movl $0x2, %eax
movl %eax, -0x80(%rbp)
jmp 0xb702e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb6ffb
movl $0x3, %eax
movl %eax, -0x84(%rbp)
jmp 0xb7025
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
jmp 0xb71a1
movq -0x10(%rbp), %rdi
xorl %esi, %esi
leaq -0x40(%rbp), %rax
leaq -0x20(%rbp), %rdx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb4070
cmpl $0x0, %eax
jne 0xb708a
jmp 0xb73c4
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x21, %eax
jne 0xb710d
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0xb710d
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f780
movq %rax, %rcx
movq -0x90(%rbp), %rax
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x21, %eax
jne 0xb710d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
leaq -0x40(%rbp), %rax
leaq -0x28(%rbp), %rcx
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb4c70
cmpl $0x0, %eax
jne 0xb7108
jmp 0xb73c4
jmp 0xb719f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %esi, %esi
leaq -0x40(%rbp), %rax
leaq -0x28(%rbp), %rcx
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb4c70
cmpl $0x0, %eax
jne 0xb7147
jmp 0xb73c4
movq -0x20(%rbp), %rdi
callq 0x97170
movl $0x2, %edi
callq 0x970a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb716a
jmp 0xb73c4
movq -0x20(%rbp), %rax
movb $0x21, (%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xb719d
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xb719f
jmp 0xb71a1
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb71b7
movb $0x1, %al
testb $0x1, %al
jne 0xb71cf
jmp 0xb71ca
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb71cf
jmp 0xb73c4
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0xb732c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
je 0xb732c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0xb732c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xb732c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xb725a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x85, %eax
je 0xb732c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb729f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb729f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa8, %eax
je 0xb732c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb72e0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb72e0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa9, %eax
je 0xb732c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0xb732c
movq -0x10(%rbp), %rdi
leaq 0x8d3cd(%rip), %rsi # 0x1446cb
leaq -0x40(%rbp), %rax
leaq 0x8d374(%rip), %rdx # 0x14467d
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb1fa0
jmp 0xb73c4
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0xe8(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0xf0(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x3f5b0
movq -0x18(%rbp), %rax
movl $0x14, (%rax)
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xb73dd
movq -0x20(%rbp), %rdi
callq 0x97170
movq -0x28(%rbp), %rdi
callq 0x97170
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
| /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_scan_block_scalar | static int
yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token,
int literal)
{
yaml_mark_t start_mark;
yaml_mark_t end_mark;
yaml_string_t string = NULL_STRING;
yaml_string_t leading_break = NULL_STRING;
yaml_string_t trailing_breaks = NULL_STRING;
int chomping = 0;
int increment = 0;
int indent = 0;
int leading_blank = 0;
int trailing_blank = 0;
if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
/* Eat the indicator '|' or '>'. */
start_mark = parser->mark;
SKIP(parser);
/* Scan the additional block scalar indicators. */
if (!CACHE(parser, 1)) goto error;
/* Check for a chomping indicator. */
if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-'))
{
/* Set the chomping method and eat the indicator. */
chomping = CHECK(parser->buffer, '+') ? +1 : -1;
SKIP(parser);
/* Check for an indentation indicator. */
if (!CACHE(parser, 1)) goto error;
if (IS_DIGIT(parser->buffer))
{
/* Check that the intendation is greater than 0. */
if (CHECK(parser->buffer, '0')) {
yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
start_mark, "found an intendation indicator equal to 0");
goto error;
}
/* Get the intendation level and eat the indicator. */
increment = AS_DIGIT(parser->buffer);
SKIP(parser);
}
}
/* Do the same as above, but in the opposite order. */
else if (IS_DIGIT(parser->buffer))
{
if (CHECK(parser->buffer, '0')) {
yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
start_mark, "found an intendation indicator equal to 0");
goto error;
}
increment = AS_DIGIT(parser->buffer);
SKIP(parser);
if (!CACHE(parser, 1)) goto error;
if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) {
chomping = CHECK(parser->buffer, '+') ? +1 : -1;
SKIP(parser);
}
}
/* Eat whitespaces and comments to the end of the line. */
if (!CACHE(parser, 1)) goto error;
while (IS_BLANK(parser->buffer)) {
SKIP(parser);
if (!CACHE(parser, 1)) goto error;
}
if (CHECK(parser->buffer, '#')) {
while (!IS_BREAKZ(parser->buffer)) {
SKIP(parser);
if (!CACHE(parser, 1)) goto error;
}
}
/* Check if we are at the end of the line. */
if (!IS_BREAKZ(parser->buffer)) {
yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
start_mark, "did not find expected comment or line break");
goto error;
}
/* Eat a line break. */
if (IS_BREAK(parser->buffer)) {
if (!CACHE(parser, 2)) goto error;
SKIP_LINE(parser);
}
end_mark = parser->mark;
/* Set the intendation level if it was specified. */
if (increment) {
indent = parser->indent >= 0 ? parser->indent+increment : increment;
}
/* Scan the leading line breaks and determine the indentation level if needed. */
if (!yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks,
start_mark, &end_mark)) goto error;
/* Scan the block scalar content. */
if (!CACHE(parser, 1)) goto error;
while ((int)parser->mark.column == indent && !IS_Z(parser->buffer))
{
/*
* We are at the beginning of a non-empty line.
*/
/* Is it a trailing whitespace? */
trailing_blank = IS_BLANK(parser->buffer);
/* Check if we need to fold the leading line break. */
if (!literal && (*leading_break.start == '\n')
&& !leading_blank && !trailing_blank)
{
/* Do we need to join the lines by space? */
if (*trailing_breaks.start == '\0') {
if (!STRING_EXTEND(parser, string)) goto error;
*(string.pointer ++) = ' ';
}
CLEAR(parser, leading_break);
}
else {
if (!JOIN(parser, string, leading_break)) goto error;
CLEAR(parser, leading_break);
}
/* Append the remaining line breaks. */
if (!JOIN(parser, string, trailing_breaks)) goto error;
CLEAR(parser, trailing_breaks);
/* Is it a leading whitespace? */
leading_blank = IS_BLANK(parser->buffer);
/* Consume the current line. */
while (!IS_BREAKZ(parser->buffer)) {
if (!READ(parser, string)) goto error;
if (!CACHE(parser, 1)) goto error;
}
/* Consume the line break. */
if (!CACHE(parser, 2)) goto error;
if (!READ_LINE(parser, leading_break)) goto error;
/* Eat the following intendation spaces and line breaks. */
if (!yaml_parser_scan_block_scalar_breaks(parser,
&indent, &trailing_breaks, start_mark, &end_mark)) goto error;
}
/* Chomp the tail. */
if (chomping != -1) {
if (!JOIN(parser, string, leading_break)) goto error;
}
if (chomping == 1) {
if (!JOIN(parser, string, trailing_breaks)) goto error;
}
/* Create a token. */
SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
literal ? YAML_LITERAL_SCALAR_STYLE : YAML_FOLDED_SCALAR_STYLE,
start_mark, end_mark);
STRING_DEL(parser, leading_break);
STRING_DEL(parser, trailing_breaks);
return 1;
error:
STRING_DEL(parser, string);
STRING_DEL(parser, leading_break);
STRING_DEL(parser, trailing_breaks);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
movl $0x0, -0x9c(%rbp)
movl $0x0, -0xa0(%rbp)
movl $0x0, -0xa4(%rbp)
movl $0x0, -0xa8(%rbp)
movl $0x0, -0xac(%rbp)
movl $0x10, %edi
callq 0x970a0
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0xb74ab
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x68(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3f5b0
movb $0x1, %al
testb $0x1, %al
jne 0xb74c0
jmp 0xb74bb
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb74c0
jmp 0xb94e2
movl $0x10, %edi
callq 0x970a0
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0xb7500
movq -0x80(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x80(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x78(%rbp)
movq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3f5b0
movb $0x1, %al
testb $0x1, %al
jne 0xb7515
jmp 0xb7510
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb7515
jmp 0xb94e2
movl $0x10, %edi
callq 0x970a0
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
je 0xb7567
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x98(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x90(%rbp)
movq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3f5b0
movb $0x1, %al
testb $0x1, %al
jne 0xb757c
jmp 0xb7577
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb757c
jmp 0xb94e2
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0xe8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0xf0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb760b
movl $0x1, %eax
movl %eax, -0xb0(%rbp)
jmp 0xb769b
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb7632
movl $0x2, %eax
movl %eax, -0xb4(%rbp)
jmp 0xb768f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb7659
movl $0x3, %eax
movl %eax, -0xb8(%rbp)
jmp 0xb7683
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0xb8(%rbp)
movl -0xb8(%rbp), %eax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
movl %eax, -0xb0(%rbp)
movl -0xb0(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb76cf
movb $0x1, %al
testb $0x1, %al
jne 0xb76e7
jmp 0xb76e2
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb76e7
jmp 0xb94e2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2b, %eax
je 0xb7711
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xb7a29
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl $0x2b, %edx
cmovel %ecx, %eax
movl %eax, -0x9c(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb779f
movl $0x1, %eax
movl %eax, -0xbc(%rbp)
jmp 0xb782f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb77c6
movl $0x2, %eax
movl %eax, -0xc0(%rbp)
jmp 0xb7823
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb77ed
movl $0x3, %eax
movl %eax, -0xc4(%rbp)
jmp 0xb7817
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0xc4(%rbp)
movl -0xc4(%rbp), %eax
movl %eax, -0xc0(%rbp)
movl -0xc0(%rbp), %eax
movl %eax, -0xbc(%rbp)
movl -0xbc(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb7863
movb $0x1, %al
testb $0x1, %al
jne 0xb787b
jmp 0xb7876
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb787b
jmp 0xb94e2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0xb7a24
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x39, %eax
jg 0xb7a24
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jne 0xb78f5
movq -0x10(%rbp), %rdi
leaq 0x8d081(%rip), %rsi # 0x144948
leaq -0x38(%rbp), %rax
leaq 0x8d094(%rip), %rdx # 0x144966
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb1fa0
jmp 0xb94e2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb7976
movl $0x1, %eax
movl %eax, -0xc8(%rbp)
jmp 0xb7a06
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb799d
movl $0x2, %eax
movl %eax, -0xcc(%rbp)
jmp 0xb79fa
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb79c4
movl $0x3, %eax
movl %eax, -0xd0(%rbp)
jmp 0xb79ee
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0xd0(%rbp)
movl -0xd0(%rbp), %eax
movl %eax, -0xcc(%rbp)
movl -0xcc(%rbp), %eax
movl %eax, -0xc8(%rbp)
movl -0xc8(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
jmp 0xb7d6a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0xb7d68
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x39, %eax
jg 0xb7d68
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jne 0xb7aa3
movq -0x10(%rbp), %rdi
leaq 0x8ced3(%rip), %rsi # 0x144948
leaq -0x38(%rbp), %rax
leaq 0x8cee6(%rip), %rdx # 0x144966
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb1fa0
jmp 0xb94e2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb7b24
movl $0x1, %eax
movl %eax, -0xd4(%rbp)
jmp 0xb7bb4
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb7b4b
movl $0x2, %eax
movl %eax, -0xd8(%rbp)
jmp 0xb7ba8
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb7b72
movl $0x3, %eax
movl %eax, -0xdc(%rbp)
jmp 0xb7b9c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0xdc(%rbp)
movl -0xdc(%rbp), %eax
movl %eax, -0xd8(%rbp)
movl -0xd8(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0xd4(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb7be8
movb $0x1, %al
testb $0x1, %al
jne 0xb7c00
jmp 0xb7bfb
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb7c00
jmp 0xb94e2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2b, %eax
je 0xb7c2a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xb7d66
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl $0x2b, %edx
cmovel %ecx, %eax
movl %eax, -0x9c(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb7cb8
movl $0x1, %eax
movl %eax, -0xe0(%rbp)
jmp 0xb7d48
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb7cdf
movl $0x2, %eax
movl %eax, -0xe4(%rbp)
jmp 0xb7d3c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb7d06
movl $0x3, %eax
movl %eax, -0xe8(%rbp)
jmp 0xb7d30
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0xe8(%rbp)
movl -0xe8(%rbp), %eax
movl %eax, -0xe4(%rbp)
movl -0xe4(%rbp), %eax
movl %eax, -0xe0(%rbp)
movl -0xe0(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
jmp 0xb7d68
jmp 0xb7d6a
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb7d80
movb $0x1, %al
testb $0x1, %al
jne 0xb7d98
jmp 0xb7d93
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb7d98
jmp 0xb94e2
jmp 0xb7d9a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xe9(%rbp)
je 0xb7dcf
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0xe9(%rbp)
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0xb7dde
jmp 0xb7f29
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb7e48
movl $0x1, %eax
movl %eax, -0xf0(%rbp)
jmp 0xb7ed8
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb7e6f
movl $0x2, %eax
movl %eax, -0xf4(%rbp)
jmp 0xb7ecc
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb7e96
movl $0x3, %eax
movl %eax, -0xf8(%rbp)
jmp 0xb7ec0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0xf8(%rbp)
movl -0xf8(%rbp), %eax
movl %eax, -0xf4(%rbp)
movl -0xf4(%rbp), %eax
movl %eax, -0xf0(%rbp)
movl -0xf0(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb7f0c
movb $0x1, %al
testb $0x1, %al
jne 0xb7f24
jmp 0xb7f1f
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb7f24
jmp 0xb94e2
jmp 0xb7d9a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0xb81c4
jmp 0xb7f42
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0xf9(%rbp)
je 0xb8066
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0xf9(%rbp)
je 0xb8066
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xb7fb8
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x85, %ecx
movb %al, -0xf9(%rbp)
je 0xb8066
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb8002
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb8002
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %ecx
movb $0x1, %al
cmpl $0xa8, %ecx
movb %al, -0xf9(%rbp)
je 0xb8066
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb804c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb804c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %ecx
movb $0x1, %al
cmpl $0xa9, %ecx
movb %al, -0xf9(%rbp)
je 0xb8066
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0xf9(%rbp)
movb -0xf9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb8077
jmp 0xb81c2
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb80e1
movl $0x1, %eax
movl %eax, -0x100(%rbp)
jmp 0xb8171
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb8108
movl $0x2, %eax
movl %eax, -0x104(%rbp)
jmp 0xb8165
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb812f
movl $0x3, %eax
movl %eax, -0x108(%rbp)
jmp 0xb8159
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0x108(%rbp)
movl -0x108(%rbp), %eax
movl %eax, -0x104(%rbp)
movl -0x104(%rbp), %eax
movl %eax, -0x100(%rbp)
movl -0x100(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb81a5
movb $0x1, %al
testb $0x1, %al
jne 0xb81bd
jmp 0xb81b8
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb81bd
jmp 0xb94e2
jmp 0xb7f42
jmp 0xb81c4
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0xb82f3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xb82f3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xb8221
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x85, %eax
je 0xb82f3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb8266
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb8266
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa8, %eax
je 0xb82f3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb82a7
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb82a7
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa9, %eax
je 0xb82f3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0xb82f3
movq -0x10(%rbp), %rdi
leaq 0x8c683(%rip), %rsi # 0x144948
leaq -0x38(%rbp), %rax
leaq 0x8c256(%rip), %rdx # 0x144526
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb1fa0
jmp 0xb94e2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0xb83de
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xb83de
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xb8350
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x85, %eax
je 0xb83de
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb8391
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb8391
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa8, %eax
je 0xb83de
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb86d0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb86d0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa9, %eax
jne 0xb86d0
movq -0x10(%rbp), %rax
cmpq $0x2, 0xa8(%rax)
jb 0xb83f4
movb $0x1, %al
testb $0x1, %al
jne 0xb840c
jmp 0xb8407
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb840c
jmp 0xb94e2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xb84a3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa, %eax
jne 0xb84a3
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
subq $0x2, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x98(%rax)
jmp 0xb86d0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0xb858e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xb858e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xb8500
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x85, %eax
je 0xb858e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb8541
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb8541
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa8, %eax
je 0xb858e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb86be
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb86be
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa9, %eax
jne 0xb86be
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb8607
movl $0x1, %eax
movl %eax, -0x10c(%rbp)
jmp 0xb8697
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb862e
movl $0x2, %eax
movl %eax, -0x110(%rbp)
jmp 0xb868b
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb8655
movl $0x3, %eax
movl %eax, -0x114(%rbp)
jmp 0xb867f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0x114(%rbp)
movl -0x114(%rbp), %eax
movl %eax, -0x110(%rbp)
movl -0x110(%rbp), %eax
movl %eax, -0x10c(%rbp)
movl -0x10c(%rbp), %edx
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movslq %edx, %rdx
addq %rdx, %rax
movq %rax, 0x98(%rcx)
movq %rax, -0x120(%rbp)
jmp 0xb86c9
xorl %eax, %eax
movq %rax, -0x120(%rbp)
jmp 0xb86c9
movq -0x120(%rbp), %rax
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0xe8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0xf0(%rax), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0xa0(%rbp)
je 0xb873b
movq -0x10(%rbp), %rax
cmpl $0x0, 0x150(%rax)
jl 0xb8723
movq -0x10(%rbp), %rax
movl 0x150(%rax), %eax
addl -0xa0(%rbp), %eax
movl %eax, -0x124(%rbp)
jmp 0xb872f
movl -0xa0(%rbp), %eax
movl %eax, -0x124(%rbp)
movl -0x124(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa4(%rbp), %rsi
leaq -0x98(%rbp), %rdx
leaq -0x38(%rbp), %rax
leaq -0x50(%rbp), %rcx
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb9570
cmpl $0x0, %eax
jne 0xb877d
jmp 0xb94e2
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb8793
movb $0x1, %al
testb $0x1, %al
jne 0xb87ab
jmp 0xb87a6
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb87ab
jmp 0xb94e2
jmp 0xb87ad
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movl %eax, %ecx
xorl %eax, %eax
cmpl -0xa4(%rbp), %ecx
movb %al, -0x125(%rbp)
jne 0xb87e6
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
sete %al
xorb $-0x1, %al
movb %al, -0x125(%rbp)
movb -0x125(%rbp), %al
testb $0x1, %al
jne 0xb87f5
jmp 0xb932d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x126(%rbp)
je 0xb882a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x126(%rbp)
movb -0x126(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xac(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xb88f9
movq -0x80(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xb88f9
cmpl $0x0, -0xa8(%rbp)
jne 0xb88f9
cmpl $0x0, -0xac(%rbp)
jne 0xb88f9
movq -0x98(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xb88d9
movq -0x58(%rbp), %rax
addq $0x5, %rax
cmpq -0x60(%rbp), %rax
jb 0xb88aa
leaq -0x68(%rbp), %rdi
leaq -0x68(%rbp), %rsi
addq $0x10, %rsi
leaq -0x68(%rbp), %rdx
addq $0x8, %rdx
callq 0x971e0
cmpl $0x0, %eax
je 0xb88b2
movb $0x1, %al
testb $0x1, %al
jne 0xb88c7
jmp 0xb88c2
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb88c7
jmp 0xb94e2
movq -0x58(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x58(%rbp)
movb $0x20, (%rax)
movq -0x80(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x3f5b0
jmp 0xb896e
leaq -0x68(%rbp), %rdi
leaq -0x68(%rbp), %rsi
addq $0x10, %rsi
leaq -0x68(%rbp), %rdx
addq $0x8, %rdx
leaq -0x80(%rbp), %rcx
leaq -0x80(%rbp), %r8
addq $0x10, %r8
leaq -0x80(%rbp), %r9
addq $0x8, %r9
callq 0x972c0
cmpl $0x0, %eax
je 0xb893b
movq -0x80(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xb8950
jmp 0xb894b
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb8950
jmp 0xb94e2
movq -0x80(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x3f5b0
leaq -0x68(%rbp), %rdi
leaq -0x68(%rbp), %rsi
addq $0x10, %rsi
leaq -0x68(%rbp), %rdx
addq $0x8, %rdx
leaq -0x98(%rbp), %rcx
leaq -0x98(%rbp), %r8
addq $0x10, %r8
leaq -0x98(%rbp), %r9
addq $0x8, %r9
callq 0x972c0
cmpl $0x0, %eax
je 0xb89bf
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xb89d4
jmp 0xb89cf
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb89d4
jmp 0xb94e2
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x3f5b0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x127(%rbp)
je 0xb8a36
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x127(%rbp)
movb -0x127(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x128(%rbp)
je 0xb8b6b
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x128(%rbp)
je 0xb8b6b
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xb8abd
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x85, %ecx
movb %al, -0x128(%rbp)
je 0xb8b6b
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb8b07
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb8b07
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %ecx
movb $0x1, %al
cmpl $0xa8, %ecx
movb %al, -0x128(%rbp)
je 0xb8b6b
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb8b51
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb8b51
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %ecx
movb $0x1, %al
cmpl $0xa9, %ecx
movb %al, -0x128(%rbp)
je 0xb8b6b
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x128(%rbp)
movb -0x128(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb8b7c
jmp 0xb8ecf
movq -0x58(%rbp), %rax
addq $0x5, %rax
cmpq -0x60(%rbp), %rax
jb 0xb8ba8
leaq -0x68(%rbp), %rdi
leaq -0x68(%rbp), %rsi
addq $0x10, %rsi
leaq -0x68(%rbp), %rdx
addq $0x8, %rdx
callq 0x971e0
cmpl $0x0, %eax
je 0xb8bb3
movb $0x1, %al
testb $0x1, %al
jne 0xb8bc8
jmp 0xb8e8f
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb8bc8
jmp 0xb8e8f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb8c14
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
jmp 0xb8e45
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xb8c94
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0x12c(%rbp)
jmp 0xb8e3f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xb8d44
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0x130(%rbp)
jmp 0xb8e33
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0xb8e1d
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0x134(%rbp)
jmp 0xb8e27
xorl %eax, %eax
movl %eax, -0x134(%rbp)
jmp 0xb8e27
movl -0x134(%rbp), %eax
movl %eax, -0x130(%rbp)
movl -0x130(%rbp), %eax
movl %eax, -0x12c(%rbp)
movl -0x12c(%rbp), %eax
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movb $0x1, %al
testb $0x1, %al
jne 0xb8e9c
jmp 0xb8e97
xorl %eax, %eax
testb $0x1, %al
jne 0xb8e9c
jmp 0xb8e97
jmp 0xb94e2
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xb8eb2
movb $0x1, %al
testb $0x1, %al
jne 0xb8eca
jmp 0xb8ec5
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb8eca
jmp 0xb94e2
jmp 0xb8a47
movq -0x10(%rbp), %rax
cmpq $0x2, 0xa8(%rax)
jb 0xb8ee5
movb $0x1, %al
testb $0x1, %al
jne 0xb8efd
jmp 0xb8ef8
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xb8efd
jmp 0xb94e2
movq -0x70(%rbp), %rax
addq $0x5, %rax
cmpq -0x78(%rbp), %rax
jb 0xb8f29
leaq -0x80(%rbp), %rdi
leaq -0x80(%rbp), %rsi
addq $0x10, %rsi
leaq -0x80(%rbp), %rdx
addq $0x8, %rdx
callq 0x971e0
cmpl $0x0, %eax
je 0xb8f34
movb $0x1, %al
testb $0x1, %al
jne 0xb8f49
jmp 0xb92d9
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb8f49
jmp 0xb92d9
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xb8ff2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa, %eax
jne 0xb8ff2
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x70(%rbp)
movb $0xa, (%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
subq $0x2, %rcx
movq %rcx, 0xa8(%rax)
jmp 0xb92d1
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0xb901c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xb90a4
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x70(%rbp)
movb $0xa, (%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rcx
movq 0xa8(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0xa8(%rcx)
movq %rax, -0x140(%rbp)
jmp 0xb92ca
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xb915f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x85, %eax
jne 0xb915f
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x70(%rbp)
movb $0xa, (%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rcx
movq 0xa8(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0xa8(%rcx)
movq %rax, -0x148(%rbp)
jmp 0xb92bc
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xb92a3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xb92a3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa8, %eax
je 0xb91c2
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa9, %eax
jne 0xb92a3
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x70(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x70(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x70(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x70(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x70(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x70(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rcx
movq 0xa8(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0xa8(%rcx)
movq %rax, -0x150(%rbp)
jmp 0xb92ae
xorl %eax, %eax
movq %rax, -0x150(%rbp)
jmp 0xb92ae
movq -0x150(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movb $0x1, %al
testb $0x1, %al
jne 0xb92e6
jmp 0xb92e1
xorl %eax, %eax
testb $0x1, %al
jne 0xb92e6
jmp 0xb92e1
jmp 0xb94e2
movq -0x10(%rbp), %rdi
leaq -0xa4(%rbp), %rsi
leaq -0x98(%rbp), %rdx
leaq -0x38(%rbp), %rax
leaq -0x50(%rbp), %rcx
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb9570
cmpl $0x0, %eax
jne 0xb9328
jmp 0xb94e2
jmp 0xb87ad
cmpl $-0x1, -0x9c(%rbp)
je 0xb938f
leaq -0x68(%rbp), %rdi
leaq -0x68(%rbp), %rsi
addq $0x10, %rsi
leaq -0x68(%rbp), %rdx
addq $0x8, %rdx
leaq -0x80(%rbp), %rcx
leaq -0x80(%rbp), %r8
addq $0x10, %r8
leaq -0x80(%rbp), %r9
addq $0x8, %r9
callq 0x972c0
cmpl $0x0, %eax
je 0xb9378
movq -0x80(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xb938d
jmp 0xb9388
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb938d
jmp 0xb94e2
jmp 0xb938f
cmpl $0x1, -0x9c(%rbp)
jne 0xb9400
leaq -0x68(%rbp), %rdi
leaq -0x68(%rbp), %rsi
addq $0x10, %rsi
leaq -0x68(%rbp), %rdx
addq $0x8, %rdx
leaq -0x98(%rbp), %rcx
leaq -0x98(%rbp), %r8
addq $0x10, %r8
leaq -0x98(%rbp), %r9
addq $0x8, %r9
callq 0x972c0
cmpl $0x0, %eax
je 0xb93e9
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xb93fe
jmp 0xb93f9
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xb93fe
jmp 0xb94e2
jmp 0xb9400
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x3f5b0
movq -0x18(%rbp), %rax
movl $0x15, (%rax)
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x68(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rcx
movq -0x68(%rbp), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %edx
movl $0x5, %ecx
movl $0x4, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x80(%rbp), %rdi
callq 0x97170
movq $0x0, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x98(%rbp), %rdi
callq 0x97170
movq $0x0, -0x90(%rbp)
movq $0x0, -0x88(%rbp)
movq $0x0, -0x98(%rbp)
movl $0x1, -0x4(%rbp)
jmp 0xb9558
movq -0x68(%rbp), %rdi
callq 0x97170
movq $0x0, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x80(%rbp), %rdi
callq 0x97170
movq $0x0, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x98(%rbp), %rdi
callq 0x97170
movq $0x0, -0x90(%rbp)
movq $0x0, -0x88(%rbp)
movq $0x0, -0x98(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_scan_plain_scalar | static int
yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token)
{
yaml_mark_t start_mark;
yaml_mark_t end_mark;
yaml_string_t string = NULL_STRING;
yaml_string_t leading_break = NULL_STRING;
yaml_string_t trailing_breaks = NULL_STRING;
yaml_string_t whitespaces = NULL_STRING;
int leading_blanks = 0;
int indent = parser->indent+1;
if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;
start_mark = end_mark = parser->mark;
/* Consume the content of the plain scalar. */
while (1)
{
/* Check for a document indicator. */
if (!CACHE(parser, 4)) goto error;
if (parser->mark.column == 0 &&
((CHECK_AT(parser->buffer, '-', 0) &&
CHECK_AT(parser->buffer, '-', 1) &&
CHECK_AT(parser->buffer, '-', 2)) ||
(CHECK_AT(parser->buffer, '.', 0) &&
CHECK_AT(parser->buffer, '.', 1) &&
CHECK_AT(parser->buffer, '.', 2))) &&
IS_BLANKZ_AT(parser->buffer, 3)) break;
/* Check for a comment. */
if (CHECK(parser->buffer, '#'))
break;
/* Consume non-blank characters. */
while (!IS_BLANKZ(parser->buffer))
{
/* Check for 'x:x' in the flow context. TODO: Fix the test "spec-08-13". */
if (parser->flow_level
&& CHECK(parser->buffer, ':')
&& !IS_BLANKZ_AT(parser->buffer, 1)) {
yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
start_mark, "found unexpected ':'");
goto error;
}
/* Check for indicators that may end a plain scalar. */
if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))
|| (parser->flow_level &&
(CHECK(parser->buffer, ',') || CHECK(parser->buffer, ':')
|| CHECK(parser->buffer, '?') || CHECK(parser->buffer, '[')
|| CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')
|| CHECK(parser->buffer, '}'))))
break;
/* Check if we need to join whitespaces and breaks. */
if (leading_blanks || whitespaces.start != whitespaces.pointer)
{
if (leading_blanks)
{
/* Do we need to fold line breaks? */
if (leading_break.start[0] == '\n') {
if (trailing_breaks.start[0] == '\0') {
if (!STRING_EXTEND(parser, string)) goto error;
*(string.pointer++) = ' ';
}
else {
if (!JOIN(parser, string, trailing_breaks)) goto error;
CLEAR(parser, trailing_breaks);
}
CLEAR(parser, leading_break);
}
else {
if (!JOIN(parser, string, leading_break)) goto error;
if (!JOIN(parser, string, trailing_breaks)) goto error;
CLEAR(parser, leading_break);
CLEAR(parser, trailing_breaks);
}
leading_blanks = 0;
}
else
{
if (!JOIN(parser, string, whitespaces)) goto error;
CLEAR(parser, whitespaces);
}
}
/* Copy the character. */
if (!READ(parser, string)) goto error;
end_mark = parser->mark;
if (!CACHE(parser, 2)) goto error;
}
/* Is it the end? */
if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))
break;
/* Consume blank characters. */
if (!CACHE(parser, 1)) goto error;
while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))
{
if (IS_BLANK(parser->buffer))
{
/* Check for tab character that abuse intendation. */
if (leading_blanks && (int)parser->mark.column < indent
&& IS_TAB(parser->buffer)) {
yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
start_mark, "found a tab character that violate intendation");
goto error;
}
/* Consume a space or a tab character. */
if (!leading_blanks) {
if (!READ(parser, whitespaces)) goto error;
}
else {
SKIP(parser);
}
}
else
{
if (!CACHE(parser, 2)) goto error;
/* Check if it is a first line break. */
if (!leading_blanks)
{
CLEAR(parser, whitespaces);
if (!READ_LINE(parser, leading_break)) goto error;
leading_blanks = 1;
}
else
{
if (!READ_LINE(parser, trailing_breaks)) goto error;
}
}
if (!CACHE(parser, 1)) goto error;
}
/* Check intendation level. */
if (!parser->flow_level && (int)parser->mark.column < indent)
break;
}
/* Create a token. */
SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
YAML_PLAIN_SCALAR_STYLE, start_mark, end_mark);
/* Note that we change the 'simple_key_allowed' flag. */
if (leading_blanks) {
parser->simple_key_allowed = 1;
}
STRING_DEL(parser, leading_break);
STRING_DEL(parser, trailing_breaks);
STRING_DEL(parser, whitespaces);
return 1;
error:
STRING_DEL(parser, string);
STRING_DEL(parser, leading_break);
STRING_DEL(parser, trailing_breaks);
STRING_DEL(parser, whitespaces);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
movl $0x0, -0xac(%rbp)
movq -0x10(%rbp), %rax
movl 0x150(%rax), %eax
addl $0x1, %eax
movl %eax, -0xb0(%rbp)
movl $0x10, %edi
callq 0x970a0
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xbd116
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x60(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3f5b0
movb $0x1, %al
testb $0x1, %al
jne 0xbd12b
jmp 0xbd126
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbd12b
jmp 0xbf1b1
movl $0x10, %edi
callq 0x970a0
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0xbd16b
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x78(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x70(%rbp)
movq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3f5b0
movb $0x1, %al
testb $0x1, %al
jne 0xbd180
jmp 0xbd17b
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbd180
jmp 0xbf1b1
movl $0x10, %edi
callq 0x970a0
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0xbd1cf
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x90(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x88(%rbp)
movq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3f5b0
movb $0x1, %al
testb $0x1, %al
jne 0xbd1e4
jmp 0xbd1df
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbd1e4
jmp 0xbf1b1
movl $0x10, %edi
callq 0x970a0
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0xbd236
movq -0xa8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0xa8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xa0(%rbp)
movq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3f5b0
movb $0x1, %al
testb $0x1, %al
jne 0xbd24b
jmp 0xbd246
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbd24b
jmp 0xbf1b1
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0xe8(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0xf0(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x4, 0xa8(%rax)
jb 0xbd29e
movb $0x1, %al
testb $0x1, %al
jne 0xbd2b6
jmp 0xbd2b1
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xbd2b6
jmp 0xbf1b1
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
jne 0xbd477
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xbd303
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x2d, %eax
jne 0xbd303
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0x2d, %eax
je 0xbd34a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xbd477
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x2e, %eax
jne 0xbd477
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0x2e, %eax
jne 0xbd477
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0x20, %eax
je 0xbd472
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0x9, %eax
je 0xbd472
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0xd, %eax
je 0xbd472
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0xa, %eax
je 0xbd472
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0xc2, %eax
jne 0xbd3da
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x4(%rax), %eax
cmpl $0x85, %eax
je 0xbd472
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0xe2, %eax
jne 0xbd41c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x4(%rax), %eax
cmpl $0x80, %eax
jne 0xbd41c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x5(%rax), %eax
cmpl $0xa8, %eax
je 0xbd472
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0xe2, %eax
jne 0xbd45e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x4(%rax), %eax
cmpl $0x80, %eax
jne 0xbd45e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x5(%rax), %eax
cmpl $0xa9, %eax
je 0xbd472
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
jne 0xbd477
jmp 0xbf09a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0xbd48f
jmp 0xbf09a
jmp 0xbd491
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xb1(%rbp)
je 0xbd5ff
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0xb1(%rbp)
je 0xbd5ff
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0xb2(%rbp)
je 0xbd5f3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0xb2(%rbp)
je 0xbd5f3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xbd545
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x85, %ecx
movb %al, -0xb2(%rbp)
je 0xbd5f3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xbd58f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xbd58f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %ecx
movb $0x1, %al
cmpl $0xa8, %ecx
movb %al, -0xb2(%rbp)
je 0xbd5f3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xbd5d9
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xbd5d9
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %ecx
movb $0x1, %al
cmpl $0xa9, %ecx
movb %al, -0xb2(%rbp)
je 0xbd5f3
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0xb2(%rbp)
movb -0xb2(%rbp), %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xbd610
jmp 0xbdffa
movq -0x10(%rbp), %rax
cmpl $0x0, 0x100(%rax)
je 0xbd79d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x3a, %eax
jne 0xbd79d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x20, %eax
je 0xbd79d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x9, %eax
je 0xbd79d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xd, %eax
je 0xbd79d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa, %eax
je 0xbd79d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xc2, %eax
jne 0xbd6c8
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0x85, %eax
je 0xbd79d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xe2, %eax
jne 0xbd70e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0x80, %eax
jne 0xbd70e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0xa8, %eax
je 0xbd79d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xe2, %eax
jne 0xbd750
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0x80, %eax
jne 0xbd750
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0xa9, %eax
je 0xbd79d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0xbd79d
movq -0x10(%rbp), %rdi
leaq 0x87351(%rip), %rsi # 0x144ac0
leaq -0x30(%rbp), %rax
leaq 0x87364(%rip), %rdx # 0x144ade
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb1fa0
jmp 0xbf1b1
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x3a, %eax
jne 0xbd8e8
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x20, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x9, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xd, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xc2, %eax
jne 0xbd844
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0x85, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xe2, %eax
jne 0xbd88a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0x80, %eax
jne 0xbd88a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0xa8, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xe2, %eax
jne 0xbd8d0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0x80, %eax
jne 0xbd8d0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0xa9, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x100(%rax)
je 0xbd983
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2c, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x3a, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x3f, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x5b, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x5d, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x7b, %eax
je 0xbd97e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x7d, %eax
jne 0xbd983
jmp 0xbdffa
cmpl $0x0, -0xac(%rbp)
jne 0xbd9a0
movq -0xa8(%rbp), %rax
cmpq -0x98(%rbp), %rax
je 0xbdc82
cmpl $0x0, -0xac(%rbp)
je 0xbdbed
movq -0x78(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xbdadc
movq -0x90(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xbda2c
movq -0x50(%rbp), %rax
addq $0x5, %rax
cmpq -0x58(%rbp), %rax
jb 0xbd9f8
leaq -0x60(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0x10, %rsi
leaq -0x60(%rbp), %rdx
addq $0x8, %rdx
callq 0x971e0
cmpl $0x0, %eax
je 0xbda00
movb $0x1, %al
testb $0x1, %al
jne 0xbda15
jmp 0xbda10
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbda15
jmp 0xbf1b1
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x50(%rbp)
movb $0x20, (%rax)
jmp 0xbdab9
leaq -0x60(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0x10, %rsi
leaq -0x60(%rbp), %rdx
addq $0x8, %rdx
leaq -0x90(%rbp), %rcx
leaq -0x90(%rbp), %r8
addq $0x10, %r8
leaq -0x90(%rbp), %r9
addq $0x8, %r9
callq 0x972c0
cmpl $0x0, %eax
je 0xbda7a
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xbda8f
jmp 0xbda8a
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbda8f
jmp 0xbf1b1
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rdx
movq -0x90(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x3f5b0
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x3f5b0
jmp 0xbdbde
leaq -0x60(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0x10, %rsi
leaq -0x60(%rbp), %rdx
addq $0x8, %rdx
leaq -0x78(%rbp), %rcx
leaq -0x78(%rbp), %r8
addq $0x10, %r8
leaq -0x78(%rbp), %r9
addq $0x8, %r9
callq 0x972c0
cmpl $0x0, %eax
je 0xbdb1e
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xbdb33
jmp 0xbdb2e
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbdb33
jmp 0xbf1b1
leaq -0x60(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0x10, %rsi
leaq -0x60(%rbp), %rdx
addq $0x8, %rdx
leaq -0x90(%rbp), %rcx
leaq -0x90(%rbp), %r8
addq $0x10, %r8
leaq -0x90(%rbp), %r9
addq $0x8, %r9
callq 0x972c0
cmpl $0x0, %eax
je 0xbdb81
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xbdb96
jmp 0xbdb91
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbdb96
jmp 0xbf1b1
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x3f5b0
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rdx
movq -0x90(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x3f5b0
movl $0x0, -0xac(%rbp)
jmp 0xbdc80
leaq -0x60(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0x10, %rsi
leaq -0x60(%rbp), %rdx
addq $0x8, %rdx
leaq -0xa8(%rbp), %rcx
leaq -0xa8(%rbp), %r8
addq $0x10, %r8
leaq -0xa8(%rbp), %r9
addq $0x8, %r9
callq 0x972c0
cmpl $0x0, %eax
je 0xbdc3e
movq -0xa8(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xbdc53
jmp 0xbdc4e
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbdc53
jmp 0xbf1b1
movq -0xa8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rdx
movq -0xa8(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x3f5b0
jmp 0xbdc82
movq -0x50(%rbp), %rax
addq $0x5, %rax
cmpq -0x58(%rbp), %rax
jb 0xbdcae
leaq -0x60(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0x10, %rsi
leaq -0x60(%rbp), %rdx
addq $0x8, %rdx
callq 0x971e0
cmpl $0x0, %eax
je 0xbdcb9
movb $0x1, %al
testb $0x1, %al
jne 0xbdcce
jmp 0xbdf95
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbdcce
jmp 0xbdf95
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xbdd1a
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
jmp 0xbdf4b
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xbdd9a
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x50(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0xb8(%rbp)
jmp 0xbdf45
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xbde4a
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x50(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x50(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0xbc(%rbp)
jmp 0xbdf39
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0xbdf23
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x50(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x50(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x50(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0xc0(%rbp)
jmp 0xbdf2d
xorl %eax, %eax
movl %eax, -0xc0(%rbp)
jmp 0xbdf2d
movl -0xc0(%rbp), %eax
movl %eax, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
movl %eax, -0xb8(%rbp)
movl -0xb8(%rbp), %eax
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movb $0x1, %al
testb $0x1, %al
jne 0xbdfa2
jmp 0xbdf9d
xorl %eax, %eax
testb $0x1, %al
jne 0xbdfa2
jmp 0xbdf9d
jmp 0xbf1b1
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0xe8(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0xf0(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x2, 0xa8(%rax)
jb 0xbdfdd
movb $0x1, %al
testb $0x1, %al
jne 0xbdff5
jmp 0xbdff0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xbdff5
jmp 0xbf1b1
jmp 0xbd491
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0xbe10c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
je 0xbe10c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0xbe10c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xbe10c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xbe085
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x85, %eax
je 0xbe10c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xbe0c6
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xbe0c6
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa8, %eax
je 0xbe10c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xbe107
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xbe107
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa9, %eax
je 0xbe10c
jmp 0xbf09a
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xbe122
movb $0x1, %al
testb $0x1, %al
jne 0xbe13a
jmp 0xbe135
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xbe13a
jmp 0xbf1b1
jmp 0xbe13c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xc1(%rbp)
je 0xbe2ac
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0xc1(%rbp)
je 0xbe2ac
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0xc2(%rbp)
je 0xbe2a0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0xc2(%rbp)
je 0xbe2a0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xbe1f0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x85, %ecx
movb %al, -0xc2(%rbp)
je 0xbe2a0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xbe23a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xbe23a
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %ecx
movb $0x1, %al
cmpl $0xa8, %ecx
movb %al, -0xc2(%rbp)
je 0xbe2a0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xe2, %ecx
movb %al, -0xc3(%rbp)
jne 0xbe294
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x80, %ecx
movb %al, -0xc3(%rbp)
jne 0xbe294
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa9, %eax
sete %al
movb %al, -0xc3(%rbp)
movb -0xc3(%rbp), %al
movb %al, -0xc2(%rbp)
movb -0xc2(%rbp), %al
movb %al, -0xc1(%rbp)
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0xbe2bb
jmp 0xbf073
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0xbe2e5
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0xbe7e7
cmpl $0x0, -0xac(%rbp)
je 0xbe34d
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
cmpl -0xb0(%rbp), %eax
jge 0xbe34d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0xbe34d
movq -0x10(%rbp), %rdi
leaq 0x867a1(%rip), %rsi # 0x144ac0
leaq -0x30(%rbp), %rax
leaq 0x867c9(%rip), %rdx # 0x144af3
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb1fa0
jmp 0xbf1b1
cmpl $0x0, -0xac(%rbp)
jne 0xbe6ca
movq -0x98(%rbp), %rax
addq $0x5, %rax
cmpq -0xa0(%rbp), %rax
jb 0xbe395
leaq -0xa8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
addq $0x10, %rsi
leaq -0xa8(%rbp), %rdx
addq $0x8, %rdx
callq 0x971e0
cmpl $0x0, %eax
je 0xbe3a0
movb $0x1, %al
testb $0x1, %al
jne 0xbe3b5
jmp 0xbe6b8
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbe3b5
jmp 0xbe6b8
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xbe407
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x98(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
jmp 0xbe66e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xbe493
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x98(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x98(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0xc8(%rbp)
jmp 0xbe668
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xbe555
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x98(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x98(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x98(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0xcc(%rbp)
jmp 0xbe65c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0xbe646
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x98(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x98(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x98(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %al
movq -0x98(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movb %al, (%rcx)
movzbl %al, %eax
movl %eax, -0xd0(%rbp)
jmp 0xbe650
xorl %eax, %eax
movl %eax, -0xd0(%rbp)
jmp 0xbe650
movl -0xd0(%rbp), %eax
movl %eax, -0xcc(%rbp)
movl -0xcc(%rbp), %eax
movl %eax, -0xc8(%rbp)
movl -0xc8(%rbp), %eax
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movb $0x1, %al
testb $0x1, %al
jne 0xbe6c5
jmp 0xbe6c0
xorl %eax, %eax
testb $0x1, %al
jne 0xbe6c5
jmp 0xbe6c0
jmp 0xbf1b1
jmp 0xbe7e2
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xbe734
movl $0x1, %eax
movl %eax, -0xd4(%rbp)
jmp 0xbe7c4
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0xbe75b
movl $0x2, %eax
movl %eax, -0xd8(%rbp)
jmp 0xbe7b8
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0xbe782
movl $0x3, %eax
movl %eax, -0xdc(%rbp)
jmp 0xbe7ac
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %edx
andl $0xf8, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0xf0, %edx
cmovel %ecx, %eax
movl %eax, -0xdc(%rbp)
movl -0xdc(%rbp), %eax
movl %eax, -0xd8(%rbp)
movl -0xd8(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0xd4(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
jmp 0xbf040
movq -0x10(%rbp), %rax
cmpq $0x2, 0xa8(%rax)
jb 0xbe7fd
movb $0x1, %al
testb $0x1, %al
jne 0xbe815
jmp 0xbe810
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xbe815
jmp 0xbf1b1
cmpl $0x0, -0xac(%rbp)
jne 0xbec47
movq -0xa8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rdx
movq -0xa8(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x3f5b0
movq -0x68(%rbp), %rax
addq $0x5, %rax
cmpq -0x70(%rbp), %rax
jb 0xbe87b
leaq -0x78(%rbp), %rdi
leaq -0x78(%rbp), %rsi
addq $0x10, %rsi
leaq -0x78(%rbp), %rdx
addq $0x8, %rdx
callq 0x971e0
cmpl $0x0, %eax
je 0xbe886
movb $0x1, %al
testb $0x1, %al
jne 0xbe89b
jmp 0xbec2b
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbe89b
jmp 0xbec2b
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xbe944
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa, %eax
jne 0xbe944
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x68(%rbp)
movb $0xa, (%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
subq $0x2, %rcx
movq %rcx, 0xa8(%rax)
jmp 0xbec23
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0xbe96e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xbe9f6
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x68(%rbp)
movb $0xa, (%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rcx
movq 0xa8(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0xa8(%rcx)
movq %rax, -0xe8(%rbp)
jmp 0xbec1c
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xbeab1
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x85, %eax
jne 0xbeab1
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x68(%rbp)
movb $0xa, (%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rcx
movq 0xa8(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0xa8(%rcx)
movq %rax, -0xf0(%rbp)
jmp 0xbec0e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xbebf5
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xbebf5
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa8, %eax
je 0xbeb14
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa9, %eax
jne 0xbebf5
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x68(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x68(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x68(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x68(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x68(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x68(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rcx
movq 0xa8(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0xa8(%rcx)
movq %rax, -0xf8(%rbp)
jmp 0xbec00
xorl %eax, %eax
movq %rax, -0xf8(%rbp)
jmp 0xbec00
movq -0xf8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movb $0x1, %al
testb $0x1, %al
jne 0xbec38
jmp 0xbec33
xorl %eax, %eax
testb $0x1, %al
jne 0xbec38
jmp 0xbec33
jmp 0xbf1b1
movl $0x1, -0xac(%rbp)
jmp 0xbf03e
movq -0x80(%rbp), %rax
addq $0x5, %rax
cmpq -0x88(%rbp), %rax
jb 0xbec7f
leaq -0x90(%rbp), %rdi
leaq -0x90(%rbp), %rsi
addq $0x10, %rsi
leaq -0x90(%rbp), %rdx
addq $0x8, %rdx
callq 0x971e0
cmpl $0x0, %eax
je 0xbec8a
movb $0x1, %al
testb $0x1, %al
jne 0xbec9f
jmp 0xbf02f
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0xbec9f
jmp 0xbf02f
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xbed48
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa, %eax
jne 0xbed48
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x80(%rbp)
movb $0xa, (%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
subq $0x2, %rcx
movq %rcx, 0xa8(%rax)
jmp 0xbf027
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
je 0xbed72
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xbedfa
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x80(%rbp)
movb $0xa, (%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rcx
movq 0xa8(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0xa8(%rcx)
movq %rax, -0x100(%rbp)
jmp 0xbf020
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xc2, %eax
jne 0xbeeb5
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x85, %eax
jne 0xbeeb5
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x80(%rbp)
movb $0xa, (%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rcx
movq 0xa8(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0xa8(%rcx)
movq %rax, -0x108(%rbp)
jmp 0xbf012
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl (%rax), %eax
cmpl $0xe2, %eax
jne 0xbeff9
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x80, %eax
jne 0xbeff9
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa8, %eax
je 0xbef18
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xa9, %eax
jne 0xbeff9
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x98(%rcx)
movb (%rax), %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rcx
movq 0xa8(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0xa8(%rcx)
movq %rax, -0x110(%rbp)
jmp 0xbf004
xorl %eax, %eax
movq %rax, -0x110(%rbp)
jmp 0xbf004
movq -0x110(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x100(%rbp), %rax
movb $0x1, %al
testb $0x1, %al
jne 0xbf03c
jmp 0xbf037
xorl %eax, %eax
testb $0x1, %al
jne 0xbf03c
jmp 0xbf037
jmp 0xbf1b1
jmp 0xbf03e
jmp 0xbf040
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0xbf056
movb $0x1, %al
testb $0x1, %al
jne 0xbf06e
jmp 0xbf069
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xacfb0
cmpl $0x0, %eax
jne 0xbf06e
jmp 0xbf1b1
jmp 0xbe13c
movq -0x10(%rbp), %rax
cmpl $0x0, 0x100(%rax)
jne 0xbf095
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
cmpl -0xb0(%rbp), %eax
jge 0xbf095
jmp 0xbf09a
jmp 0xbd288
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x3f5b0
movq -0x18(%rbp), %rax
movl $0x15, (%rax)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x60(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rcx
movq -0x60(%rbp), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x18(%rax)
cmpl $0x0, -0xac(%rbp)
je 0xbf12d
movq -0x10(%rbp), %rax
movl $0x1, 0x154(%rax)
movq -0x78(%rbp), %rdi
callq 0x97170
movq $0x0, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x90(%rbp), %rdi
callq 0x97170
movq $0x0, -0x88(%rbp)
movq $0x0, -0x80(%rbp)
movq $0x0, -0x90(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x97170
movq $0x0, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
movq $0x0, -0xa8(%rbp)
movl $0x1, -0x4(%rbp)
jmp 0xbf251
movq -0x60(%rbp), %rdi
callq 0x97170
movq $0x0, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x78(%rbp), %rdi
callq 0x97170
movq $0x0, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x90(%rbp), %rdi
callq 0x97170
movq $0x0, -0x88(%rbp)
movq $0x0, -0x80(%rbp)
movq $0x0, -0x90(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x97170
movq $0x0, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
movq $0x0, -0xa8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
nopl (%rax)
| /urbit[P]h2o/deps/yaml/src/scanner.c |
brotli::ZopfliIterate(unsigned long, unsigned long, unsigned char const*, unsigned long, unsigned long, brotli::ZopfliCostModel const&, std::vector<unsigned int, std::allocator<unsigned int>> const&, std::vector<brotli::BackwardMatch, std::allocator<brotli::BackwardMatch>> const&, int*, unsigned long*, brotli::Command*, unsigned long*, unsigned long*) | void ZopfliIterate(size_t num_bytes,
size_t position,
const uint8_t* ringbuffer,
size_t ringbuffer_mask,
const size_t max_backward_limit,
const ZopfliCostModel& model,
const std::vector<uint32_t>& num_matches,
const std::vector<BackwardMatch>& matches,
int* dist_cache,
size_t* last_insert_len,
Command* commands,
size_t* num_commands,
size_t* num_literals) {
const Command * const orig_commands = commands;
std::vector<ZopfliNode> nodes(num_bytes + 1);
nodes[0].length = 0;
nodes[0].cost = 0;
memcpy(nodes[0].distance_cache, dist_cache, 4 * sizeof(dist_cache[0]));
StartPosQueue queue(3);
const double min_cost_cmd = model.GetMinCostCmd();
size_t cur_match_pos = 0;
for (size_t i = 0; i + 3 < num_bytes; i++) {
size_t cur_ix = position + i;
size_t cur_ix_masked = cur_ix & ringbuffer_mask;
size_t max_distance = std::min(cur_ix, max_backward_limit);
size_t max_length = num_bytes - i;
queue.Push(i, nodes[i].cost - model.GetLiteralCosts(0, i));
const size_t min_len = ComputeMinimumCopyLength(queue, nodes, model,
i, min_cost_cmd);
// Go over the command starting positions in order of increasing cost
// difference.
for (size_t k = 0; k < 5 && k < queue.size(); ++k) {
const size_t start = queue.GetStartPos(k);
const double start_costdiff =
nodes[start].cost - model.GetLiteralCosts(0, start);
const int* dist_cache2 = &nodes[start].distance_cache[0];
// Look for last distance matches using the distance cache from this
// starting position.
size_t best_len = min_len - 1;
for (size_t j = 0; j < kNumDistanceShortCodes; ++j) {
const size_t idx = kDistanceCacheIndex[j];
const size_t backward =
static_cast<size_t>(dist_cache2[idx] + kDistanceCacheOffset[j]);
size_t prev_ix = cur_ix - backward;
if (prev_ix >= cur_ix) {
continue;
}
if (PREDICT_FALSE(backward > max_distance)) {
continue;
}
prev_ix &= ringbuffer_mask;
if (cur_ix_masked + best_len > ringbuffer_mask ||
prev_ix + best_len > ringbuffer_mask ||
ringbuffer[cur_ix_masked + best_len] !=
ringbuffer[prev_ix + best_len]) {
continue;
}
const size_t len =
FindMatchLengthWithLimit(&ringbuffer[prev_ix],
&ringbuffer[cur_ix_masked],
max_length);
for (size_t l = best_len + 1; l <= len; ++l) {
const size_t inslen = i - start;
double cmd_cost = model.GetCommandCost(j, l, inslen);
double cost = start_costdiff + cmd_cost + model.GetLiteralCosts(0, i);
if (cost < nodes[i + l].cost) {
UpdateZopfliNode(&nodes[0], i, start, l, l, backward, j,
max_distance, dist_cache2, cost);
}
best_len = l;
}
}
// At higher iterations look only for new last distance matches, since
// looking only for new command start positions with the same distances
// does not help much.
if (k >= 2) continue;
// Loop through all possible copy lengths at this position.
size_t len = min_len;
for (size_t j = 0; j < num_matches[i]; ++j) {
BackwardMatch match = matches[cur_match_pos + j];
size_t dist = match.distance;
bool is_dictionary_match = dist > max_distance;
// We already tried all possible last distance matches, so we can use
// normal distance code here.
size_t dist_code = dist + 15;
// Try all copy lengths up until the maximum copy length corresponding
// to this distance. If the distance refers to the static dictionary, or
// the maximum length is long enough, try only one maximum length.
size_t max_len = match.length();
if (len < max_len && (is_dictionary_match || max_len > kMaxZopfliLen)) {
len = max_len;
}
for (; len <= max_len; ++len) {
size_t len_code = is_dictionary_match ? match.length_code() : len;
const size_t inslen = i - start;
double cmd_cost = model.GetCommandCost(dist_code, len_code, inslen);
double cost = start_costdiff + cmd_cost + model.GetLiteralCosts(0, i);
if (cost < nodes[i + len].cost) {
UpdateZopfliNode(&nodes[0], i, start, len, len_code, dist,
dist_code, max_distance, dist_cache2, cost);
}
}
}
}
cur_match_pos += num_matches[i];
// The zopflification can be too slow in case of very long lengths, so in
// such case skip it all, it does not cost a lot of compression ratio.
if (num_matches[i] == 1 &&
matches[cur_match_pos - 1].length() > kMaxZopfliLen) {
i += matches[cur_match_pos - 1].length() - 1;
queue.Clear();
}
}
std::vector<uint32_t> backwards;
size_t index = num_bytes;
while (nodes[index].cost == kInfinity) --index;
while (index != 0) {
size_t len = nodes[index].length + nodes[index].insert_length;
backwards.push_back(static_cast<uint32_t>(len));
index -= len;
}
std::vector<uint32_t> path;
for (size_t i = backwards.size(); i > 0; i--) {
path.push_back(backwards[i - 1]);
}
size_t pos = 0;
for (size_t i = 0; i < path.size(); i++) {
const ZopfliNode& next = nodes[pos + path[i]];
size_t copy_length = next.length;
size_t insert_length = next.insert_length;
pos += insert_length;
if (i == 0) {
insert_length += *last_insert_len;
*last_insert_len = 0;
}
size_t distance = next.distance;
size_t len_code = next.length_code;
size_t max_distance = std::min(position + pos, max_backward_limit);
bool is_dictionary = (distance > max_distance);
size_t dist_code = next.distance_code;
Command cmd(insert_length, copy_length, len_code, dist_code);
*commands++ = cmd;
if (!is_dictionary && dist_code > 0) {
dist_cache[3] = dist_cache[2];
dist_cache[2] = dist_cache[1];
dist_cache[1] = dist_cache[0];
dist_cache[0] = static_cast<int>(distance);
}
*num_literals += insert_length;
insert_length = 0;
pos += copy_length;
}
*last_insert_len += num_bytes - pos;
*num_commands += static_cast<size_t>(commands - orig_commands);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x398, %rsp # imm = 0x398
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq 0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
incq %rax
movq %rax, -0x270(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0xc18e0
movq -0x270(%rbp), %rsi
movq -0x268(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0xc1900
jmp 0xbf8bf
leaq -0x59(%rbp), %rdi
callq 0xc1970
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x278(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x280(%rbp)
callq 0xc1990
movq -0x280(%rbp), %rdi
movq -0x278(%rbp), %rsi
movl $0x0, (%rax)
callq 0xc1990
movq -0x280(%rbp), %rdi
movq -0x278(%rbp), %rsi
movq $0x0, 0x28(%rax)
callq 0xc1990
movq 0x20(%rbp), %rcx
movups (%rcx), %xmm0
movups %xmm0, 0xc(%rax)
leaq -0x98(%rbp), %rdi
movl $0x3, %esi
callq 0xc19b0
jmp 0xbf935
movq -0x38(%rbp), %rdi
callq 0xc1a50
movsd %xmm0, -0x288(%rbp)
jmp 0xbf948
movsd -0x288(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
movq $0x0, -0xa8(%rbp)
movq $0x0, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
addq $0x3, %rax
cmpq -0x10(%rbp), %rax
jae 0xc02a5
movq -0x18(%rbp), %rax
movq -0xb0(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq -0x28(%rbp), %rcx
andq %rcx, %rax
movq %rax, -0xc0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc1a70
movq %rax, -0x290(%rbp)
jmp 0xbf9c6
movq -0x290(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movq -0xb0(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xd0(%rbp)
movq -0xb0(%rbp), %rsi
movq %rsi, -0x2a8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xc1990
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x2a0(%rbp)
movq -0x38(%rbp), %rdi
movq -0xb0(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xc1850
movsd %xmm0, -0x298(%rbp)
jmp 0xbfa2e
movq -0x2a8(%rbp), %rsi
movsd -0x298(%rbp), %xmm1
movsd -0x2a0(%rbp), %xmm0
subsd %xmm1, %xmm0
leaq -0x98(%rbp), %rdi
callq 0xc1ab0
jmp 0xbfa57
movq -0x38(%rbp), %rdx
movq -0xb0(%rbp), %rcx
movsd -0xa0(%rbp), %xmm0
leaq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xbf710
movq %rax, -0x2b0(%rbp)
jmp 0xbfa83
movq -0x2b0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq $0x0, -0xe0(%rbp)
xorl %eax, %eax
cmpq $0x5, -0xe0(%rbp)
movb %al, -0x2b1(%rbp)
jae 0xbfaeb
movq -0xe0(%rbp), %rax
movq %rax, -0x2c8(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xc1c10
movq %rax, -0x2c0(%rbp)
jmp 0xbfad1
movq -0x2c8(%rbp), %rax
movq -0x2c0(%rbp), %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0x2b1(%rbp)
movb -0x2b1(%rbp), %al
testb $0x1, %al
jne 0xbfafa
jmp 0xc01d2
movq -0xe0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0xc17f0
movq %rax, -0x2d0(%rbp)
jmp 0xbfb16
movq -0x2d0(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc1990
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x2e0(%rbp)
movq -0x38(%rbp), %rdi
movq -0xe8(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xc1850
movsd %xmm0, -0x2d8(%rbp)
jmp 0xbfb5f
movsd -0x2d8(%rbp), %xmm1
movsd -0x2e0(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0xf0(%rbp)
movq -0xe8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc1990
addq $0xc, %rax
movq %rax, -0xf8(%rbp)
movq -0xd8(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x100(%rbp)
movq $0x0, -0x108(%rbp)
cmpq $0x10, -0x108(%rbp)
jae 0xbfed3
movq -0x108(%rbp), %rcx
leaq 0x85031(%rip), %rax # 0x144c00
movl (%rax,%rcx,4), %eax
movq %rax, -0x110(%rbp)
movq -0xf8(%rbp), %rax
movq -0x110(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x108(%rbp), %rdx
leaq 0x85048(%rip), %rcx # 0x144c40
addl (%rcx,%rdx,4), %eax
cltq
movq %rax, -0x118(%rbp)
movq -0xb8(%rbp), %rax
subq -0x118(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x120(%rbp), %rax
cmpq -0xb8(%rbp), %rax
jb 0xbfc6a
jmp 0xbfebc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0xc1970
jmp 0xc0703
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xc06fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xc06ee
movq -0x118(%rbp), %rax
cmpq -0xc8(%rbp), %rax
jbe 0xbfc7f
jmp 0xbfebc
movq -0x28(%rbp), %rax
andq -0x120(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0xc0(%rbp), %rax
addq -0x100(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0xbfce9
movq -0x120(%rbp), %rax
addq -0x100(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0xbfce9
movq -0x20(%rbp), %rax
movq -0xc0(%rbp), %rcx
addq -0x100(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movq -0x120(%rbp), %rdx
addq -0x100(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xbfcee
jmp 0xbfebc
movq -0x20(%rbp), %rsi
movq -0x120(%rbp), %rax
movq %rsi, %rdi
addq %rax, %rdi
movq -0xc0(%rbp), %rax
addq %rax, %rsi
movq -0xd0(%rbp), %rdx
callq 0xc0710
movq %rax, -0x2e8(%rbp)
jmp 0xbfd1e
movq -0x2e8(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x100(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rax
cmpq -0x128(%rbp), %rax
ja 0xbfeba
movq -0xb0(%rbp), %rax
movq -0xe8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x138(%rbp)
movq -0x38(%rbp), %rdi
movq -0x108(%rbp), %rsi
movq -0x130(%rbp), %rdx
movq -0x138(%rbp), %rcx
callq 0xc1c50
movsd %xmm0, -0x2f0(%rbp)
jmp 0xbfd92
movsd -0x2f0(%rbp), %xmm0
movsd %xmm0, -0x140(%rbp)
movsd -0xf0(%rbp), %xmm0
movsd -0x140(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x300(%rbp)
movq -0x38(%rbp), %rdi
movq -0xb0(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xc1850
movsd %xmm0, -0x2f8(%rbp)
jmp 0xbfddc
movsd -0x2f8(%rbp), %xmm1
movsd -0x300(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x148(%rbp)
movsd -0x148(%rbp), %xmm0
movsd %xmm0, -0x308(%rbp)
movq -0xb0(%rbp), %rsi
addq -0x130(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc1990
movsd -0x308(%rbp), %xmm1
movsd 0x28(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xbfe95
xorl %eax, %eax
movl %eax, %esi
leaq -0x58(%rbp), %rdi
callq 0xc1990
movq %rax, %rdi
movq -0xb0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
movq -0x130(%rbp), %r8
movq -0x118(%rbp), %r9
movq -0x108(%rbp), %rcx
movq -0xc8(%rbp), %r10
movq -0xf8(%rbp), %r11
movsd -0x148(%rbp), %xmm0
movq %rsp, %rax
movq %r11, 0x10(%rax)
movq %r10, 0x8(%rax)
movq %rcx, (%rax)
movq %r8, %rcx
callq 0xc1d50
jmp 0xbfe93
jmp 0xbfe95
movq -0x130(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x130(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x130(%rbp)
jmp 0xbfd3e
jmp 0xbfebc
movq -0x108(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x108(%rbp)
jmp 0xbfbb3
cmpq $0x2, -0xe0(%rbp)
jb 0xbfee2
jmp 0xc01bb
movq -0xd8(%rbp), %rax
movq %rax, -0x150(%rbp)
movq $0x0, -0x158(%rbp)
movq -0x158(%rbp), %rax
movq %rax, -0x310(%rbp)
movq 0x10(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xc1e10
movq %rax, %rcx
movq -0x310(%rbp), %rax
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0xc01b9
movq 0x18(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0x158(%rbp), %rax
addq %rax, %rsi
callq 0xc1e30
movq (%rax), %rax
movq %rax, -0x160(%rbp)
movl -0x160(%rbp), %eax
movq %rax, -0x168(%rbp)
movq -0x168(%rbp), %rax
movq -0xc8(%rbp), %rcx
subq %rcx, %rax
seta -0x169(%rbp)
movq -0x168(%rbp), %rax
addq $0xf, %rax
movq %rax, -0x178(%rbp)
leaq -0x160(%rbp), %rdi
callq 0xc1e50
movq %rax, -0x318(%rbp)
jmp 0xbff9e
movq -0x318(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0x150(%rbp), %rax
cmpq -0x180(%rbp), %rax
jae 0xbffe0
testb $0x1, -0x169(%rbp)
jne 0xbffd2
cmpq $0x145, -0x180(%rbp) # imm = 0x145
jbe 0xbffe0
movq -0x180(%rbp), %rax
movq %rax, -0x150(%rbp)
jmp 0xbffe2
movq -0x150(%rbp), %rax
cmpq -0x180(%rbp), %rax
ja 0xc01a0
testb $0x1, -0x169(%rbp)
je 0xc0024
leaq -0x160(%rbp), %rdi
callq 0xc1e70
movq %rax, -0x320(%rbp)
jmp 0xc0014
movq -0x320(%rbp), %rax
movq %rax, -0x328(%rbp)
jmp 0xc0032
movq -0x150(%rbp), %rax
movq %rax, -0x328(%rbp)
movq -0x328(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0xb0(%rbp), %rax
movq -0xe8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x190(%rbp)
movq -0x38(%rbp), %rdi
movq -0x178(%rbp), %rsi
movq -0x188(%rbp), %rdx
movq -0x190(%rbp), %rcx
callq 0xc1c50
movsd %xmm0, -0x330(%rbp)
jmp 0xc0080
movsd -0x330(%rbp), %xmm0
movsd %xmm0, -0x198(%rbp)
movsd -0xf0(%rbp), %xmm0
movsd -0x198(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x340(%rbp)
movq -0x38(%rbp), %rdi
movq -0xb0(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xc1850
movsd %xmm0, -0x338(%rbp)
jmp 0xc00ca
movsd -0x338(%rbp), %xmm1
movsd -0x340(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x1a0(%rbp)
movsd -0x1a0(%rbp), %xmm0
movsd %xmm0, -0x348(%rbp)
movq -0xb0(%rbp), %rsi
addq -0x150(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc1990
movsd -0x348(%rbp), %xmm1
movsd 0x28(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc0187
xorl %eax, %eax
movl %eax, %esi
leaq -0x58(%rbp), %rdi
callq 0xc1990
movq %rax, %rdi
movq -0xb0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
movq -0x150(%rbp), %rcx
movq -0x188(%rbp), %r8
movq -0x168(%rbp), %r9
movq -0x178(%rbp), %r10
movq -0xc8(%rbp), %r11
movq -0xf8(%rbp), %rbx
movsd -0x1a0(%rbp), %xmm0
movq %rsp, %rax
movq %rbx, 0x10(%rax)
movq %r11, 0x8(%rax)
movq %r10, (%rax)
callq 0xc1d50
jmp 0xc0185
jmp 0xc0187
jmp 0xc0189
movq -0x150(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x150(%rbp)
jmp 0xbffe2
jmp 0xc01a2
movq -0x158(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x158(%rbp)
jmp 0xbfefb
jmp 0xc01bb
movq -0xe0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xe0(%rbp)
jmp 0xbfa9c
movq 0x10(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xc1e10
movl (%rax), %eax
addq -0xa8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x10(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xc1e10
cmpl $0x1, (%rax)
jne 0xc028c
movq 0x18(%rbp), %rdi
movq -0xa8(%rbp), %rsi
decq %rsi
callq 0xc1e30
movq %rax, %rdi
callq 0xc1e50
movq %rax, -0x350(%rbp)
jmp 0xc022f
movq -0x350(%rbp), %rax
cmpq $0x145, %rax # imm = 0x145
jbe 0xc028c
movq 0x18(%rbp), %rdi
movq -0xa8(%rbp), %rsi
decq %rsi
callq 0xc1e30
movq %rax, %rdi
callq 0xc1e50
movq %rax, -0x358(%rbp)
jmp 0xc0262
movq -0x358(%rbp), %rax
movq -0xb0(%rbp), %rcx
leaq -0x1(%rax,%rcx), %rax
movq %rax, -0xb0(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xc1ec0
jmp 0xc028a
jmp 0xc028c
jmp 0xc028e
movq -0xb0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb0(%rbp)
jmp 0xbf96e
leaq -0x1b8(%rbp), %rdi
callq 0xc1ee0
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x1c0(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc1990
movsd 0x28(%rax), %xmm0
movsd 0x848df(%rip), %xmm1 # 0x144bb8
ucomisd %xmm1, %xmm0
jne 0xc02f5
jp 0xc02f5
movq -0x1c0(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x1c0(%rbp)
jmp 0xc02bc
jmp 0xc02f7
cmpq $0x0, -0x1c0(%rbp)
je 0xc039b
movq -0x1c0(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x368(%rbp)
callq 0xc1990
movq -0x368(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x35c(%rbp)
movq -0x1c0(%rbp), %rsi
callq 0xc1990
movq %rax, %rcx
movl -0x35c(%rbp), %eax
movl 0x20(%rcx), %ecx
addl %ecx, %eax
movq %rax, -0x1c8(%rbp)
movl -0x1c8(%rbp), %eax
movl %eax, -0x1cc(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x1cc(%rbp), %rsi
callq 0xc1f00
jmp 0xc036d
movq -0x1c8(%rbp), %rcx
movq -0x1c0(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x1c0(%rbp)
jmp 0xc02f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xc06e2
leaq -0x1e8(%rbp), %rdi
callq 0xc1ee0
leaq -0x1b8(%rbp), %rdi
callq 0xc1f30
movq %rax, -0x1f0(%rbp)
cmpq $0x0, -0x1f0(%rbp)
jbe 0xc041e
movq -0x1f0(%rbp), %rsi
decq %rsi
leaq -0x1b8(%rbp), %rdi
callq 0xc1fc0
movq %rax, %rsi
leaq -0x1e8(%rbp), %rdi
callq 0xc1f50
jmp 0xc03eb
jmp 0xc03ed
movq -0x1f0(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x1f0(%rbp)
jmp 0xc03ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0xc2070
jmp 0xc06e2
movq $0x0, -0x1f8(%rbp)
movq $0x0, -0x200(%rbp)
movq -0x200(%rbp), %rax
movq %rax, -0x370(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0xc1f30
movq %rax, %rcx
movq -0x370(%rbp), %rax
cmpq %rcx, %rax
jae 0xc0674
movq -0x1f8(%rbp), %rax
movq %rax, -0x378(%rbp)
movq -0x200(%rbp), %rsi
leaq -0x1e8(%rbp), %rdi
callq 0xc1fc0
movq -0x378(%rbp), %rsi
movl (%rax), %eax
addq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xc1990
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x210(%rbp)
movq -0x208(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rax
addq -0x1f8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
cmpq $0x0, -0x200(%rbp)
jne 0xc04fe
movq 0x28(%rbp), %rax
movq (%rax), %rax
addq -0x218(%rbp), %rax
movq %rax, -0x218(%rbp)
movq 0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x208(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x220(%rbp)
movq -0x208(%rbp), %rax
movl 0x1c(%rax), %eax
movq %rax, -0x228(%rbp)
movq -0x18(%rbp), %rax
movq -0x1f8(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x238(%rbp)
leaq -0x238(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc1a70
movq %rax, -0x380(%rbp)
jmp 0xc054e
movq -0x380(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x230(%rbp)
movq -0x220(%rbp), %rax
movq -0x230(%rbp), %rcx
subq %rcx, %rax
seta -0x239(%rbp)
movq -0x208(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x248(%rbp)
movq -0x218(%rbp), %rsi
movq -0x210(%rbp), %rdx
movq -0x228(%rbp), %rcx
movq -0x248(%rbp), %r8
leaq -0x260(%rbp), %rdi
callq 0xc1fe0
jmp 0xc05b2
movq 0x30(%rbp), %rax
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x30(%rbp)
movq -0x260(%rbp), %rcx
movq %rcx, (%rax)
movq -0x258(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x250(%rbp), %rcx
movq %rcx, 0x10(%rax)
testb $0x1, -0x239(%rbp)
jne 0xc062c
cmpq $0x0, -0x248(%rbp)
jbe 0xc062c
movq 0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq 0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rbp), %rax
movl (%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x220(%rbp), %rax
movl %eax, %ecx
movq 0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x218(%rbp), %rcx
movq 0x40(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x218(%rbp)
movq -0x210(%rbp), %rax
addq -0x1f8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movq -0x200(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x200(%rbp)
jmp 0xc0434
movq -0x10(%rbp), %rcx
subq -0x1f8(%rbp), %rcx
movq 0x28(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq 0x38(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
leaq -0x1e8(%rbp), %rdi
callq 0xc2070
leaq -0x1b8(%rbp), %rdi
callq 0xc2070
leaq -0x98(%rbp), %rdi
callq 0xc20d0
leaq -0x58(%rbp), %rdi
callq 0xc20f0
addq $0x398, %rsp # imm = 0x398
popq %rbx
popq %rbp
retq
leaq -0x1b8(%rbp), %rdi
callq 0xc2070
leaq -0x98(%rbp), %rdi
callq 0xc20d0
leaq -0x58(%rbp), %rdi
callq 0xc20f0
movq -0x68(%rbp), %rdi
callq 0x3fc20
nopl (%rax)
| /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
brotli::CombineLengthCodes(unsigned short, unsigned short, bool) | static inline uint16_t CombineLengthCodes(
uint16_t inscode, uint16_t copycode, bool use_last_distance) {
uint16_t bits64 =
static_cast<uint16_t>((copycode & 0x7u) | ((inscode & 0x7u) << 3));
if (use_last_distance && inscode < 8 && copycode < 16) {
return (copycode < 8) ? bits64 : (bits64 | 64);
} else {
// "To convert an insert-and-copy length code to an insert length code and
// a copy length code, the following table can be used"
static const uint16_t cells[9] = { 128u, 192u, 384u, 256u, 320u, 512u,
448u, 576u, 640u };
return cells[(copycode >> 3) + 3 * (inscode >> 3)] | bits64;
}
} | pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movw %si, %cx
movw %di, %dx
movw %dx, -0x4(%rbp)
movw %cx, -0x6(%rbp)
andb $0x1, %al
movb %al, -0x7(%rbp)
movzwl -0x6(%rbp), %eax
andl $0x7, %eax
movzwl -0x4(%rbp), %ecx
andl $0x7, %ecx
shll $0x3, %ecx
orl %ecx, %eax
movw %ax, -0xa(%rbp)
testb $0x1, -0x7(%rbp)
je 0xc162d
movzwl -0x4(%rbp), %eax
cmpl $0x8, %eax
jge 0xc162d
movzwl -0x6(%rbp), %eax
cmpl $0x10, %eax
jge 0xc162d
movzwl -0x6(%rbp), %eax
cmpl $0x8, %eax
jge 0xc161a
movzwl -0xa(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xc1624
movzwl -0xa(%rbp), %eax
orl $0x40, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movw %ax, -0x2(%rbp)
jmp 0xc1658
movzwl -0x6(%rbp), %eax
sarl $0x3, %eax
movzwl -0x4(%rbp), %ecx
sarl $0x3, %ecx
imull $0x3, %ecx, %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x83646(%rip), %rax # 0x144c90
movzwl (%rax,%rcx,2), %eax
movzwl -0xa(%rbp), %ecx
orl %ecx, %eax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nop
| /urbit[P]h2o/deps/brotli/enc/././command.h |
brotli::Log2FloorNonZero(unsigned long) | static inline uint32_t Log2FloorNonZero(size_t n) {
#ifdef __GNUC__
return 31u ^ static_cast<uint32_t>(__builtin_clz(static_cast<uint32_t>(n)));
#else
uint32_t result = 0;
while (n >>= 1) result++;
return result;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
bsrl %eax, %eax
xorl $0x1f, %eax
xorl $0x1f, %eax
popq %rbp
retq
nopw (%rax,%rax)
| /urbit[P]h2o/deps/brotli/enc/./././fast_log.h |
brotli::GetLengthCode(unsigned long, unsigned long, bool, unsigned short*, unsigned long*) | static inline void GetLengthCode(size_t insertlen, size_t copylen,
bool use_last_distance,
uint16_t* code, uint64_t* extra) {
uint16_t inscode = GetInsertLengthCode(insertlen);
uint16_t copycode = GetCopyLengthCode(copylen);
uint64_t insnumextra = kInsExtra[inscode];
uint64_t numextra = insnumextra + kCopyExtra[copycode];
uint64_t insextraval = insertlen - kInsBase[inscode];
uint64_t copyextraval = copylen - kCopyBase[copycode];
*code = CombineLengthCodes(inscode, copycode, use_last_distance);
*extra = (numextra << 48) | (copyextraval << insnumextra) | insextraval;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc1460
movw %ax, -0x2a(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc1520
movw %ax, -0x2c(%rbp)
movzwl -0x2a(%rbp), %eax
movl %eax, %ecx
leaq 0x12d95a(%rip), %rax # 0x1ef020
movl (%rax,%rcx,4), %eax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzwl -0x2c(%rbp), %ecx
movl %ecx, %edx
leaq 0x12d9a2(%rip), %rcx # 0x1ef080
movl (%rcx,%rdx,4), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movzwl -0x2a(%rbp), %ecx
movl %ecx, %edx
leaq 0x12d9e7(%rip), %rcx # 0x1ef0e0
movl (%rcx,%rdx,4), %ecx
subq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movzwl -0x2c(%rbp), %ecx
movl %ecx, %edx
leaq 0x12da2c(%rip), %rcx # 0x1ef140
movl (%rcx,%rdx,4), %ecx
subq %rcx, %rax
movq %rax, -0x50(%rbp)
movw -0x2a(%rbp), %dx
movw -0x2c(%rbp), %cx
movb -0x11(%rbp), %al
andb $0x1, %al
movzwl %dx, %edi
movzwl %cx, %esi
movzbl %al, %edx
callq 0xc15c0
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movq -0x40(%rbp), %rax
shlq $0x30, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
shlq %cl, %rax
movq -0x58(%rbp), %rcx
orq %rax, %rcx
orq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /urbit[P]h2o/deps/brotli/enc/././command.h |
brotli::StartPosQueue::Push(unsigned long, double) | void Push(size_t pos, double costdiff) {
if (costdiff == kInfinity) {
// We can't start a command from an unreachable start position.
// E.g. position 1 in a stream is always unreachable, because all commands
// have a copy of at least length 2.
return;
}
size_t offset = -idx_ & mask_;
++idx_;
size_t len = size();
q_[offset] = std::make_pair(pos, costdiff);
/* Restore the sorted order. In the list of |len| items at most |len - 1|
adjacent element comparisons / swaps are required. */
for (size_t i = 1; i < len; ++i) {
if (q_[offset & mask_].second > q_[(offset + 1) & mask_].second) {
std::swap(q_[offset & mask_], q_[(offset + 1) & mask_]);
}
++offset;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x830de(%rip), %xmm1 # 0x144bb8
ucomisd %xmm1, %xmm0
jne 0xc1ae7
jp 0xc1ae7
jmp 0xc1c03
movq -0x48(%rbp), %rdi
xorl %eax, %eax
subq 0x20(%rdi), %rax
andq (%rdi), %rax
movq %rax, -0x20(%rbp)
movq 0x20(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x20(%rdi)
callq 0xc1c10
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xc74a0
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movsd %xmm0, -0x30(%rbp)
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0xc74d0
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0xc74f0
movq $0x1, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xc1c03
movq -0x48(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
andq (%rax), %rsi
callq 0xc74d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movsd 0x8(%rcx), %xmm0
movsd %xmm0, -0x50(%rbp)
movq %rax, %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
andq (%rax), %rsi
callq 0xc74d0
movsd -0x50(%rbp), %xmm0
ucomisd 0x8(%rax), %xmm0
jbe 0xc1be6
movq -0x48(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
andq (%rax), %rsi
callq 0xc74d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq %rax, %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
andq (%rax), %rsi
callq 0xc74d0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xc7520
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xc1b48
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
brotli::ZopfliCostModel::GetCommandCost(unsigned long, unsigned long, unsigned long) const | double GetCommandCost(
size_t dist_code, size_t length_code, size_t insert_length) const {
uint16_t inscode = GetInsertLengthCode(insert_length);
uint16_t copycode = GetCopyLengthCode(length_code);
uint16_t cmdcode = CombineLengthCodes(inscode, copycode, dist_code == 0);
uint16_t dist_symbol;
uint32_t distextra;
PrefixEncodeCopyDistance(dist_code, 0, 0, &dist_symbol, &distextra);
uint32_t distnumextra = distextra >> 24;
double result = static_cast<double>(
kInsExtra[inscode] + kCopyExtra[copycode] + distnumextra);
result += cost_cmd_[cmdcode];
if (cmdcode >= 128) result += cost_dist_[dist_symbol];
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc1460
movw %ax, -0x22(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc1520
movw %ax, -0x24(%rbp)
movzwl -0x22(%rbp), %edi
movzwl -0x24(%rbp), %esi
movq -0x10(%rbp), %rax
testq %rax, %rax
sete %al
movzbl %al, %edx
callq 0xc15c0
movw %ax, -0x26(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x28(%rbp), %rcx
leaq -0x2c(%rbp), %r8
movq %rdx, %rsi
callq 0xc7660
movq -0x40(%rbp), %rdi
movzbl -0x29(%rbp), %eax
movl %eax, -0x30(%rbp)
movzwl -0x22(%rbp), %eax
movl %eax, %ecx
leaq 0x12d348(%rip), %rax # 0x1ef020
movl (%rax,%rcx,4), %eax
movzwl -0x24(%rbp), %ecx
movl %ecx, %edx
leaq 0x12d398(%rip), %rcx # 0x1ef080
movl (%rcx,%rdx,4), %ecx
addl %ecx, %eax
movl -0x30(%rbp), %ecx
addl %ecx, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x38(%rbp)
movzwl -0x26(%rbp), %eax
movl %eax, %esi
callq 0xc6d70
movsd (%rax), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movzwl -0x26(%rbp), %eax
cmpl $0x80, %eax
jl 0xc1d41
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movzwl -0x28(%rbp), %eax
movl %eax, %esi
callq 0xc6d70
movsd (%rax), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
brotli::Command::Command(unsigned long, unsigned long, unsigned long, unsigned long) | Command(size_t insertlen, size_t copylen, size_t copylen_code,
size_t distance_code)
: insert_len_(static_cast<uint32_t>(insertlen))
, copy_len_(static_cast<uint32_t>(copylen)) {
// The distance prefix and extra bits are stored in this Command as if
// npostfix and ndirect were 0, they are only recomputed later after the
// clustering if needed.
PrefixEncodeCopyDistance(distance_code, 0, 0, &dist_prefix_, &dist_extra_);
GetLengthCode(insertlen, copylen_code, dist_prefix_ == 0,
&cmd_prefix_, &cmd_extra_);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %r8
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl %eax, (%r8)
movq -0x18(%rbp), %rax
movl %eax, 0x4(%r8)
movq -0x28(%rbp), %rdi
movq %r8, %rcx
addq $0x16, %rcx
addq $0x10, %r8
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xc7660
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movzwl 0x16(%r8), %eax
cmpl $0x0, %eax
sete %al
movq %r8, %rcx
addq $0x14, %rcx
addq $0x8, %r8
movzbl %al, %edx
andl $0x1, %edx
callq 0xc1680
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /urbit[P]h2o/deps/brotli/enc/././command.h |
brotli::HashToBinaryTree::FindAllMatches(unsigned char const*, unsigned long, unsigned long, unsigned long, unsigned long, brotli::BackwardMatch*) | size_t FindAllMatches(const uint8_t* data,
const size_t ring_buffer_mask,
const size_t cur_ix,
const size_t max_length,
const size_t max_backward,
BackwardMatch* matches) {
BackwardMatch* const orig_matches = matches;
const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
size_t best_len = 1;
size_t stop = cur_ix - 64;
if (cur_ix < 64) { stop = 0; }
for (size_t i = cur_ix - 1; i > stop && best_len <= 2; --i) {
size_t prev_ix = i;
const size_t backward = cur_ix - prev_ix;
if (PREDICT_FALSE(backward > max_backward)) {
break;
}
prev_ix &= ring_buffer_mask;
if (data[cur_ix_masked] != data[prev_ix] ||
data[cur_ix_masked + 1] != data[prev_ix + 1]) {
continue;
}
const size_t len =
FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
max_length);
if (len > best_len) {
best_len = len;
*matches++ = BackwardMatch(backward, len);
}
}
if (best_len < max_length) {
matches = StoreAndFindMatches(data, cur_ix, ring_buffer_mask,
max_length, &best_len, matches);
}
std::vector<uint32_t> dict_matches(kMaxDictionaryMatchLen + 1,
kInvalidMatch);
size_t minlen = std::max<size_t>(4, best_len + 1);
if (FindAllStaticDictionaryMatches(&data[cur_ix_masked], minlen, max_length,
&dict_matches[0])) {
size_t maxlen = std::min<size_t>(kMaxDictionaryMatchLen, max_length);
for (size_t l = minlen; l <= maxlen; ++l) {
uint32_t dict_id = dict_matches[l];
if (dict_id < kInvalidMatch) {
*matches++ = BackwardMatch(max_backward + (dict_id >> 5) + 1, l,
dict_id & 31);
}
}
}
return static_cast<size_t>(matches - orig_matches);
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
andq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x1, -0x48(%rbp)
movq -0x20(%rbp), %rax
subq $0x40, %rax
movq %rax, -0x50(%rbp)
cmpq $0x40, -0x20(%rbp)
jae 0xc2529
movq $0x0, -0x50(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
xorl %eax, %eax
cmpq -0x50(%rbp), %rcx
movb %al, -0xe9(%rbp)
jbe 0xc2555
cmpq $0x2, -0x48(%rbp)
setbe %al
movb %al, -0xe9(%rbp)
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0xc2564
jmp 0xc2638
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
subq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0xc2587
jmp 0xc2638
movq -0x18(%rbp), %rax
andq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x60(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xc25cd
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x60(%rbp), %rdx
movzbl 0x1(%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xc25cf
jmp 0xc2627
movq -0x10(%rbp), %rdi
addq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xc0710
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x48(%rbp), %rax
jbe 0xc2625
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0xc7d70
movq 0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rbp)
movq -0x78(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xc2627
movq -0x58(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xc2535
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xc266e
movq -0xe8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
movq 0x10(%rbp), %rax
leaq -0x48(%rbp), %r9
movq %rax, (%rsp)
callq 0xc7930
movq %rax, 0x10(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0xc22b0
movq -0xf8(%rbp), %rcx
leaq 0x82621(%rip), %rdx # 0x144cb0
leaq -0x90(%rbp), %rdi
movl $0x26, %esi
callq 0xc7dc0
jmp 0xc26a2
leaq -0x91(%rbp), %rdi
callq 0xc2340
movq $0x4, -0xb8(%rbp)
movq -0x48(%rbp), %rax
incq %rax
movq %rax, -0xc0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xc7e40
movq %rax, -0x100(%rbp)
jmp 0xc26e3
movq -0x100(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x120(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x110(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x90(%rbp), %rdi
callq 0xc1fc0
movq -0x120(%rbp), %rdi
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdx
movq %rax, %rcx
callq 0xfd7d0
movb %al, -0x101(%rbp)
jmp 0xc2754
movb -0x101(%rbp), %al
testb $0x1, %al
jne 0xc2763
jmp 0xc286e
leaq 0x8254e(%rip), %rdi # 0x144cb8
leaq -0x28(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
cmpq -0xc8(%rbp), %rax
ja 0xc286c
movq -0xd0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0xc1fc0
movl (%rax), %eax
movl %eax, -0xd4(%rbp)
cmpl $0xfffffff, -0xd4(%rbp) # imm = 0xFFFFFFF
jae 0xc2853
movq -0x30(%rbp), %rcx
movl -0xd4(%rbp), %eax
movl %eax, %edx
shrl $0x5, %edx
leaq 0x1(%rcx,%rdx), %rsi
movq -0xd0(%rbp), %rdx
andl $0x1f, %eax
movl %eax, %ecx
leaq -0xdc(%rbp), %rdi
callq 0xc7e80
jmp 0xc27f8
movq 0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rbp)
movq -0xdc(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xc2853
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x91(%rbp), %rdi
callq 0xc2340
jmp 0xc28a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xc2070
jmp 0xc28a0
jmp 0xc2855
movq -0xd0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd0(%rbp)
jmp 0xc278b
jmp 0xc286e
movq 0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x128(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xc2070
movq -0x128(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x3fc20
nopl (%rax)
| /urbit[P]h2o/deps/brotli/enc/././hash.h |
brotli::ZopfliCostModel::SetFromLiteralCosts(unsigned long, unsigned long, unsigned char const*, unsigned long) | void SetFromLiteralCosts(size_t num_bytes,
size_t position,
const uint8_t* ringbuffer,
size_t ringbuffer_mask) {
std::vector<float> literal_cost(num_bytes + 1);
EstimateBitCostsForLiterals(position, num_bytes, ringbuffer_mask,
ringbuffer, &literal_cost[0]);
literal_costs_.resize(num_bytes + 1);
literal_costs_[0] = 0.0;
for (size_t i = 0; i < num_bytes; ++i) {
literal_costs_[i + 1] = literal_costs_[i] + literal_cost[i];
}
cost_cmd_.resize(kNumCommandPrefixes);
cost_dist_.resize(kNumDistancePrefixes);
for (uint32_t i = 0; i < kNumCommandPrefixes; ++i) {
cost_cmd_[i] = FastLog2(11 + i);
}
for (uint32_t i = 0; i < kNumDistancePrefixes; ++i) {
cost_dist_[i] = FastLog2(20 + i);
}
min_cost_cmd_ = FastLog2(11);
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
incq %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xc8610
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xc8630
jmp 0xc2972
leaq -0x41(%rbp), %rdi
callq 0xc86a0
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0xc86c0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
movq %rax, %r8
callq 0xf93f0
jmp 0xc29da
movq -0x80(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
incq %rsi
callq 0xc86e0
jmp 0xc29f0
movq -0x80(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc8770
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xc2aca
movq -0x80(%rbp), %rdi
addq $0x30, %rdi
movq -0x60(%rbp), %rsi
callq 0xc8770
movsd (%rax), %xmm0
movsd %xmm0, -0xb0(%rbp)
movq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xc86c0
movsd -0xb0(%rbp), %xmm0
movq -0x80(%rbp), %rdi
movss (%rax), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0xa8(%rbp)
addq $0x30, %rdi
movq -0x60(%rbp), %rsi
addq $0x1, %rsi
callq 0xc8770
movsd -0xa8(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0xc2a10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0xc86a0
jmp 0xc2bc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc8790
jmp 0xc2bc1
movq -0x80(%rbp), %rdi
movl $0x2c0, %esi # imm = 0x2C0
callq 0xc86e0
jmp 0xc2ada
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
movl $0x208, %esi # imm = 0x208
callq 0xc86e0
jmp 0xc2aee
movl $0x0, -0x64(%rbp)
cmpl $0x2c0, -0x64(%rbp) # imm = 0x2C0
jae 0xc2b3a
movl -0x64(%rbp), %eax
addl $0xb, %eax
movl %eax, %edi
callq 0xc1780
movsd %xmm0, -0xb8(%rbp)
jmp 0xc2b15
movq -0x80(%rbp), %rdi
movl -0x64(%rbp), %eax
movl %eax, %esi
callq 0xc8770
movsd -0xb8(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0xc2af5
movl $0x0, -0x68(%rbp)
cmpl $0x208, -0x68(%rbp) # imm = 0x208
jae 0xc2b8a
movl -0x68(%rbp), %eax
addl $0x14, %eax
movl %eax, %edi
callq 0xc1780
movsd %xmm0, -0xc0(%rbp)
jmp 0xc2b61
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
movl -0x68(%rbp), %eax
movl %eax, %esi
callq 0xc8770
movsd -0xc0(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0xc2b41
movl $0xb, %edi
callq 0xc1780
movsd %xmm0, -0xc8(%rbp)
jmp 0xc2b9e
movq -0x80(%rbp), %rax
movsd -0xc8(%rbp), %xmm0
movsd %xmm0, 0x48(%rax)
leaq -0x40(%rbp), %rdi
callq 0xc8790
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3fc20
nopw (%rax,%rax)
| /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.