LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt_setvertex(stbtt_vertex*, unsigned char, int, int, int, int)
static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)
{
   v->type = type;
   v->x = (stbtt_int16) x;
   v->y = (stbtt_int16) y;
   v->cx = (stbtt_int16) cx;
   v->cy = (stbtt_int16) cy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xc(%rax)
movl -0x10(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movl -0x18(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_rectpack.h
// Function: stbrp_init_target(stbrp_context*, int, int, stbrp_node*, int)
STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
{
   int i;
#ifndef STBRP_LARGE_RECTS
   STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
#endif

   for (i=0; i < num_nodes-1; ++i)
      nodes[i].next = &nodes[i+1];
   nodes[i].next = NULL;
   context->init_mode = STBRP__INIT_skyline;
   context->heuristic = STBRP_HEURISTIC_Skyline_default;
   context->free_head = &nodes[0];
   context->active_head = &context->extra[0];
   context->width = width;
   context->height = height;
   context->num_nodes = num_nodes;
   stbrp_setup_allow_out_of_mem(context, 0);

   // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
   context->extra[0].x = 0;
   context->extra[0].y = 0;
   context->extra[0].next = &context->extra[1];
   context->extra[1].x = (stbrp_coord) width;
#ifdef STBRP_LARGE_RECTS
   context->extra[1].y = (1<<30);
#else
   context->extra[1].y = 65535;
#endif
   context->extra[1].next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0xffff, -0xc(%rbp)     # imm = 0xFFFF
movb %al, -0x21(%rbp)
jg 0x121555
cmpl $0xffff, -0x10(%rbp)    # imm = 0xFFFF
setle %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x12155e
jmp 0x121560
jmp 0x12157f
leaq 0x69d4f(%rip), %rdi     # 0x18b2b6
leaq 0x69d6c(%rip), %rsi     # 0x18b2da
movl $0x10a, %edx            # imm = 0x10A
leaq 0x69d7f(%rip), %rcx     # 0x18b2f9
callq 0xd180
jmp 0x121581
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1215c6
movq -0x18(%rbp), %rcx
movl -0x20(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x4, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x121588
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
addq $0x28, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x121690
movq -0x8(%rbp), %rax
movw $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2a(%rax)
movq -0x8(%rbp), %rcx
addq $0x28, %rcx
addq $0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0xc(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x38(%rax)
movq -0x8(%rbp), %rax
movw $0xffff, 0x3a(%rax)     # imm = 0xFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_rectpack.h
// Function: rect_height_compare(void const*, void const*)
static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
{
   const stbrp_rect *p = (const stbrp_rect *) a;
   const stbrp_rect *q = (const stbrp_rect *) b;
   if (p->h > q->h)
      return -1;
   if (p->h < q->h)
      return  1;
   return (p->w > q->w) ? -1 : (p->w < q->w);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x6(%rax), %eax
movq -0x28(%rbp), %rcx
movzwl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jle 0x121719
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x121777
movq -0x20(%rbp), %rax
movzwl 0x6(%rax), %eax
movq -0x28(%rbp), %rcx
movzwl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jge 0x121736
movl $0x1, -0x4(%rbp)
jmp 0x121777
movq -0x20(%rbp), %rax
movzwl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jle 0x121754
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x121771
movq -0x20(%rbp), %rax
movzwl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt_GetGlyphHMetrics(stbtt_fontinfo const*, int, int*, int*)
STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)
{
   stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34);
   if (glyph_index < numOfLongHorMetrics) {
      if (advanceWidth)     *advanceWidth    = ttSHORT(info->data + info->hmtx + 4*glyph_index);
      if (leftSideBearing)  *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2);
   } else {
      if (advanceWidth)     *advanceWidth    = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1));
      if (leftSideBearing)  *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics));
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x24(%rax), %rax
addq %rax, %rdi
addq $0x22, %rdi
callq 0x11f5b0
movw %ax, -0x22(%rbp)
movl -0xc(%rbp), %eax
movzwl -0x22(%rbp), %ecx
cmpl %ecx, %eax
jge 0x121fae
cmpq $0x0, -0x18(%rbp)
je 0x121f75
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rax
addq %rax, %rdi
movl -0xc(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
callq 0x11f960
movswl %ax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x121fac
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rax
addq %rax, %rdi
movl -0xc(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
addq $0x2, %rdi
callq 0x11f960
movswl %ax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x12202b
cmpq $0x0, -0x18(%rbp)
je 0x121fe5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rax
addq %rax, %rdi
movzwl -0x22(%rbp), %eax
subl $0x1, %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
callq 0x11f960
movswl %ax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x122029
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rax
addq %rax, %rdi
movzwl -0x22(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
movl -0xc(%rbp), %eax
movzwl -0x22(%rbp), %ecx
subl %ecx, %eax
shll %eax
cltq
addq %rax, %rdi
callq 0x11f960
movswl %ax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x12202b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt_MakeGlyphBitmapSubpixel(stbtt_fontinfo const*, unsigned char*, int, int, int, float, float, float, float, int)
STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph)
{
   int ix0,iy0;
   stbtt_vertex *vertices;
   int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
   stbtt__bitmap gbm;   

   stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0);
   gbm.pixels = output;
   gbm.w = out_w;
   gbm.h = out_h;
   gbm.stride = out_stride;

   if (gbm.w && gbm.h)
      stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->userdata);

   STBTT_free(vertices, info->userdata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movss %xmm1, -0x24(%rbp)
movss %xmm2, -0x28(%rbp)
movss %xmm3, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %esi
leaq -0x40(%rbp), %rdx
callq 0x122890
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %esi
movss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
movss -0x2c(%rbp), %xmm3
leaq -0x34(%rbp), %rdx
leaq -0x38(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0x1196e0
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x60(%rbp)
je 0x12217f
cmpl $0x0, -0x5c(%rbp)
je 0x12217f
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %edx
movss -0x20(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
movss -0x2c(%rbp), %xmm4
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %r8d
movq -0x8(%rbp), %rax
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
movss 0x5641c(%rip), %xmm0    # 0x17858c
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x1228e0
movq -0x40(%rbp), %rdi
callq 0xc4920
addq $0x70, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt_Rasterize(stbtt__bitmap*, float, stbtt_vertex*, int, float, float, float, float, int, int, int, void*)
STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)
{
   float scale            = scale_x > scale_y ? scale_y : scale_x;
   int winding_count      = 0;
   int *winding_lengths   = NULL;
   stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata);
   if (windings) {
      stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata);
      STBTT_free(winding_lengths, userdata);
      STBTT_free(windings, userdata);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x24(%rbp)
movss %xmm3, -0x28(%rbp)
movss %xmm4, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movl %r9d, -0x38(%rbp)
movss -0x20(%rbp), %xmm0
ucomiss -0x24(%rbp), %xmm0
jbe 0x122932
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x54(%rbp)
jmp 0x12293c
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x54(%rbp)
movss -0x54(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movss -0xc(%rbp), %xmm0
divss -0x3c(%rbp), %xmm0
movq 0x10(%rbp), %r8
leaq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x123b40
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x1229d5
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movl -0x40(%rbp), %ecx
movss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
movss -0x2c(%rbp), %xmm3
movl -0x30(%rbp), %r8d
movl -0x34(%rbp), %r9d
movl -0x38(%rbp), %r10d
movq 0x10(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x123f90
movq -0x48(%rbp), %rdi
callq 0xc4920
movq -0x50(%rbp), %rdi
callq 0xc4920
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__GetGlyphShapeT2(stbtt_fontinfo const*, int, stbtt_vertex**)
static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
{
   // runs the charstring twice, once to count and once to output (to avoid realloc)
   stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1);
   stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0);
   if (stbtt__run_charstring(info, glyph_index, &count_ctx)) {
      *pvertices = (stbtt_vertex*)STBTT_malloc(count_ctx.num_vertices*sizeof(stbtt_vertex), info->userdata);
      output_ctx.pvertices = *pvertices;
      if (stbtt__run_charstring(info, glyph_index, &output_ctx)) {
         STBTT_assert(output_ctx.num_vertices == count_ctx.num_vertices);
         return output_ctx.num_vertices;
      }
   }
   *pvertices = NULL;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0xd2f0
movl $0x1, -0x58(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0xd2f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x58(%rbp), %rdx
callq 0x11fd50
cmpl $0x0, %eax
je 0x1239f6
movslq -0x28(%rbp), %rax
imulq $0xe, %rax, %rdi
callq 0xc4820
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x90(%rbp), %rdx
callq 0x11fd50
cmpl $0x0, %eax
je 0x1239f4
jmp 0x1239c1
movl -0x60(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x1239cb
jmp 0x1239ea
leaq 0x67ad1(%rip), %rdi     # 0x18b4a3
leaq 0x67611(%rip), %rsi     # 0x18afea
movl $0x8c6, %edx            # imm = 0x8C6
leaq 0x67af0(%rip), %rcx     # 0x18b4d5
callq 0xd180
jmp 0x1239ec
movl -0x60(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x123a08
jmp 0x1239f6
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__close_shape(stbtt_vertex*, int, int, int, int, int, int, int, int, int)
static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off,
    stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
{
   if (start_off) {
      if (was_off)
         stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy);
      stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy);
   } else {
      if (was_off)
         stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy);
      else
         stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0);
   }
   return num_vertices;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x123ac1
cmpl $0x0, -0x10(%rbp)
je 0x123a8f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
cltq
imulq $0xe, %rax, %rax
addq %rax, %rdi
movl 0x20(%rbp), %edx
addl 0x10(%rbp), %edx
sarl %edx
movl 0x28(%rbp), %ecx
addl 0x18(%rbp), %ecx
sarl %ecx
movl 0x20(%rbp), %r8d
movl 0x28(%rbp), %r9d
movl $0x3, %esi
callq 0x121490
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
cltq
imulq $0xe, %rax, %rax
addq %rax, %rdi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl 0x10(%rbp), %r8d
movl 0x18(%rbp), %r9d
movl $0x3, %esi
callq 0x121490
jmp 0x123b29
cmpl $0x0, -0x10(%rbp)
je 0x123af9
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
cltq
imulq $0xe, %rax, %rax
addq %rax, %rdi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl 0x20(%rbp), %r8d
movl 0x28(%rbp), %r9d
movl $0x3, %esi
callq 0x121490
jmp 0x123b27
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
cltq
imulq $0xe, %rax, %rax
addq %rax, %rdi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl $0x2, %esi
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x121490
jmp 0x123b29
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__sort_edges_ins_sort(stbtt__edge*, int)
static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)
{
   int i,j;
   for (i=1; i < n; ++i) {
      stbtt__edge t = p[i], *a = &t;
      j = i;
      while (j > 0) {
         stbtt__edge *b = &p[j-1];
         int c = STBTT__COMPARE(a,b);
         if (!c) break;
         p[j] = p[j-1];
         --j;
      }
      if (i != j)
         p[j] = t;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x12526a
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x12522e
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x38(%rbp), %rax
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x1251ea
jmp 0x12522e
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0x14, %rax, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x14, %rdx, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1251a0
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x12525a
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x10(%rax)
jmp 0x12525c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x125162
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__new_active(stbtt__hheap*, stbtt__edge*, int, float, void*)
static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)
{
   stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata);
   float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
   STBTT_assert(z != NULL);
   //STBTT_assert(e->y0 <= start_point);
   if (!z) return z;
   z->fdx = dxdy;
   z->fdy = dxdy != 0.0f ? (1.0f/dxdy) : 0.0f;
   z->fx = e->x0 + dxdy * (start_point - e->y0);
   z->fx -= off_x;
   z->direction = e->invert ? 1.0f : -1.0f;
   z->sy = e->y0;
   z->ey = e->y1;
   z->next = 0;
   return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x20, %esi
callq 0x125f90
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
subss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm1
movq -0x18(%rbp), %rax
subss 0x4(%rax), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x125307
jmp 0x125326
leaq 0x66290(%rip), %rdi     # 0x18b59e
leaq 0x65cd5(%rip), %rsi     # 0x18afea
movl $0xad1, %edx            # imm = 0xAD1
leaq 0x66289(%rip), %rcx     # 0x18b5aa
callq 0xd180
jmp 0x125328
cmpq $0x0, -0x30(%rbp)
jne 0x12533c
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12543f
movss -0x34(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0xc(%rax)
movss -0x34(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x12535b
jp 0x12535b
jmp 0x12536f
movss 0x4b8d9(%rip), %xmm0    # 0x170c3c
divss -0x34(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
jmp 0x125379
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
jmp 0x125379
movss -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
movss -0x34(%rbp), %xmm0
movss -0x20(%rbp), %xmm2
movq -0x18(%rbp), %rax
subss 0x4(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x8(%rax)
cvtsi2ssl -0x1c(%rbp), %xmm1
movq -0x30(%rbp), %rax
movss 0x8(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movss 0x4b863(%rip), %xmm0    # 0x170c3c
movss 0x4cb9f(%rip), %xmm1    # 0x171f80
movss %xmm1, -0x40(%rbp)
cmpl $0x0, %eax
movss %xmm0, -0x3c(%rbp)
jne 0x1253fa
movss -0x40(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__hheap_cleanup(stbtt__hheap*, void*)
static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata)
{
   stbtt__hheap_chunk *c = hh->head;
   while (c) {
      stbtt__hheap_chunk *n = c->next;
      STBTT_free(c, userdata);
      c = n;
   }
}

// Assembly:
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)
cmpq $0x0, -0x18(%rbp)
je 0x125f80
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc4920
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x125f5b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__hheap_alloc(stbtt__hheap*, unsigned long, void*)
static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata)
{
   if (hh->first_free) {
      void *p = hh->first_free;
      hh->first_free = * (void **) p;
      return p;
   } else {
      if (hh->num_remaining_in_head_chunk == 0) {
         int count = (size < 32 ? 2000 : size < 128 ? 800 : 100);
         stbtt__hheap_chunk *c = (stbtt__hheap_chunk *) STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata);
         if (c == NULL)
            return NULL;
         c->next = hh->head;
         hh->head = c;
         hh->num_remaining_in_head_chunk = count;
      }
      --hh->num_remaining_in_head_chunk;
      return (char *) (hh->head) + sizeof(stbtt__hheap_chunk) + size * hh->num_remaining_in_head_chunk;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x125fd7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12608f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x126060
cmpq $0x20, -0x18(%rbp)
jae 0x125ff2
movl $0x7d0, %eax            # imm = 0x7D0
movl %eax, -0x3c(%rbp)
jmp 0x12600d
movq -0x18(%rbp), %rdx
movl $0x64, %eax
movl $0x320, %ecx            # imm = 0x320
cmpq $0x80, %rdx
cmovbl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rax
imulq %rax, %rdi
addq $0x8, %rdi
callq 0xc4820
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x12603d
movq $0x0, -0x8(%rbp)
jmp 0x12608f
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq 0x10(%rdx), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: stb__match(unsigned char const*, unsigned int)
static void stb__match(const unsigned char *data, unsigned int length)
{
    // INVERSE of memmove... write each byte before copying the next...
    IM_ASSERT(stb__dout + length <= stb__barrier_out_e);
    if (stb__dout + length > stb__barrier_out_e) { stb__dout += length; return; }
    if (data < stb__barrier_out_b) { stb__dout = stb__barrier_out_e+1; return; }
    while (length--) *stb__dout++ = *data++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0xf3122(%rip), %rax     # 0x219be8
movl -0xc(%rbp), %ecx
addq %rcx, %rax
cmpq 0xf3105(%rip), %rax     # 0x219bd8
ja 0x126ad7
jmp 0x126af6
leaq 0x64f8b(%rip), %rdi     # 0x18ba69
leaq 0x63691(%rip), %rsi     # 0x18a176
movl $0xe6f, %edx            # imm = 0xE6F
leaq 0x64fa1(%rip), %rcx     # 0x18ba92
callq 0xd180
movq 0xf30eb(%rip), %rax     # 0x219be8
movl -0xc(%rbp), %ecx
addq %rcx, %rax
cmpq 0xf30ce(%rip), %rax     # 0x219bd8
jbe 0x126b24
movl -0xc(%rbp), %ecx
movq 0xf30d2(%rip), %rax     # 0x219be8
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0xf30c6(%rip)     # 0x219be8
jmp 0x126b81
movq -0x8(%rbp), %rax
cmpq 0xf30b1(%rip), %rax     # 0x219be0
jae 0x126b45
movq 0xf30a0(%rip), %rax     # 0x219bd8
addq $0x1, %rax
movq %rax, 0xf30a5(%rip)     # 0x219be8
jmp 0x126b81
jmp 0x126b47
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x126b81
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq 0xf3079(%rip), %rax     # 0x219be8
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0xf306b(%rip)     # 0x219be8
movb %cl, (%rax)
jmp 0x126b47
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: stb__lit(unsigned char const*, unsigned int)
static void stb__lit(const unsigned char *data, unsigned int length)
{
    IM_ASSERT(stb__dout + length <= stb__barrier_out_e);
    if (stb__dout + length > stb__barrier_out_e) { stb__dout += length; return; }
    if (data < stb__barrier_in_b) { stb__dout = stb__barrier_out_e+1; return; }
    memcpy(stb__dout, data, length);
    stb__dout += length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0xf3042(%rip), %rax     # 0x219be8
movl -0xc(%rbp), %ecx
addq %rcx, %rax
cmpq 0xf3025(%rip), %rax     # 0x219bd8
ja 0x126bb7
jmp 0x126bd6
leaq 0x64eab(%rip), %rdi     # 0x18ba69
leaq 0x635b1(%rip), %rsi     # 0x18a176
movl $0xe77, %edx            # imm = 0xE77
leaq 0x64ef6(%rip), %rcx     # 0x18bac7
callq 0xd180
movq 0xf300b(%rip), %rax     # 0x219be8
movl -0xc(%rbp), %ecx
addq %rcx, %rax
cmpq 0xf2fee(%rip), %rax     # 0x219bd8
jbe 0x126c04
movl -0xc(%rbp), %ecx
movq 0xf2ff2(%rip), %rax     # 0x219be8
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0xf2fe6(%rip)     # 0x219be8
jmp 0x126c50
movq -0x8(%rbp), %rax
cmpq 0xf2fc1(%rip), %rax     # 0x219bd0
jae 0x126c25
movq 0xf2fc0(%rip), %rax     # 0x219bd8
addq $0x1, %rax
movq %rax, 0xf2fc5(%rip)     # 0x219be8
jmp 0x126c50
movq 0xf2fbc(%rip), %rdi     # 0x219be8
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0xd0a0
movl -0xc(%rbp), %ecx
movq 0xf2fa4(%rip), %rax     # 0x219be8
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0xf2f98(%rip)     # 0x219be8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableBeginInitMemory(ImGuiTable*, int)
void ImGui::TableBeginInitMemory(ImGuiTable* table, int columns_count)
{
    // Allocate single buffer for our arrays
    ImSpanAllocator<3> span_allocator;
    span_allocator.ReserveBytes(0, columns_count * sizeof(ImGuiTableColumn));
    span_allocator.ReserveBytes(1, columns_count * sizeof(ImGuiTableColumnIdx));
    span_allocator.ReserveBytes(2, columns_count * sizeof(ImGuiTableCellData));
    table->RawData = IM_ALLOC(span_allocator.GetArenaSizeInBytes());
    memset(table->RawData, 0, span_allocator.GetArenaSizeInBytes());
    span_allocator.SetArenaBasePtr(table->RawData);
    span_allocator.GetSpan(0, &table->Columns);
    span_allocator.GetSpan(1, &table->DisplayOrderToIndex);
    span_allocator.GetSpan(2, &table->RowCellData);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x137120
movslq -0xc(%rbp), %rax
imulq $0x68, %rax, %rdx
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x137150
movslq -0xc(%rbp), %rdx
shlq $0x0, %rdx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x137150
movslq -0xc(%rbp), %rdx
shlq $0x3, %rdx
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x137150
leaq -0x30(%rbp), %rdi
callq 0x1371e0
movslq %eax, %rdi
callq 0xc4820
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1371e0
movq -0x38(%rbp), %rdi
movslq %eax, %rdx
xorl %esi, %esi
callq 0xd2f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x137200
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x137220
movq -0x8(%rbp), %rdx
addq $0x20, %rdx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x137280
movq -0x8(%rbp), %rdx
addq $0x30, %rdx
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x1372e0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableResetSettings(ImGuiTable*)
void ImGui::TableResetSettings(ImGuiTable* table)
{
    table->IsInitializing = table->IsSettingsDirty = true;
    table->IsResetAllRequest = false;
    table->IsSettingsRequestLoad = false;                   // Don't reload from ini
    table->SettingsLoadedFlags = ImGuiTableFlags_None;      // Mark as nothing loaded so our initialized data becomes authoritative
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x24f(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x24a(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x251(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x24e(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x60(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetColumnWidthAuto(ImGuiTable*, ImGuiTableColumn*)
float ImGui::TableGetColumnWidthAuto(ImGuiTable* table, ImGuiTableColumn* column)
{
    const float content_width_body = ImMax(column->ContentMaxXFrozen, column->ContentMaxXUnfrozen) - column->WorkMinX;
    const float content_width_headers = column->ContentMaxXHeadersIdeal - column->WorkMinX;
    float width_auto = content_width_body;
    if (!(column->Flags & ImGuiTableColumnFlags_NoHeaderWidth))
        width_auto = ImMax(width_auto, content_width_headers);

    // Non-resizable fixed columns preserve their requested width
    if ((column->Flags & ImGuiTableColumnFlags_WidthFixed) && column->InitStretchWeightOrWidth > 0.0f)
        if (!(table->Flags & ImGuiTableFlags_Resizable) || (column->Flags & ImGuiTableColumnFlags_NoResize))
            width_auto = column->InitStretchWeightOrWidth;

    return ImMax(width_auto, table->MinColumnWidth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss 0x40(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x44(%rax), %xmm1
callq 0x12a620
movq -0x10(%rbp), %rax
subss 0x34(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movss 0x4c(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0x34(%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x12cd4a
movss -0x1c(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
callq 0x12a620
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x12cd96
movq -0x10(%rbp), %rax
movss 0x1c(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x12cd96
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x12cd86
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x12cd94
movq -0x10(%rbp), %rax
movss 0x1c(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0x12cd96
movss -0x1c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss 0xb4(%rax), %xmm1
callq 0x12a620
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableSetColumnWidthAutoSingle(ImGuiTable*, int)
void ImGui::TableSetColumnWidthAutoSingle(ImGuiTable* table, int column_n)
{
    // Single auto width uses auto-fit
    ImGuiTableColumn* column = &table->Columns[column_n];
    if (!column->IsEnabled)
        return;
    column->CannotSkipItemsQueue = (1 << 0);
    table->AutoFitSingleColumn = (ImGuiTableColumnIdx)column_n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
callq 0xeea20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x5a(%rax)
jne 0x12dc1f
jmp 0x12dc36
movq -0x18(%rbp), %rax
movb $0x1, 0x63(%rax)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x236(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableOpenContextMenu(int)
void ImGui::TableOpenContextMenu(int column_n)
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (column_n == -1 && table->CurrentColumn != -1)   // When called within a column automatically use this one (for consistency)
        column_n = table->CurrentColumn;
    if (column_n == table->ColumnsCount)                // To facilitate using with TableGetHoveredColumn()
        column_n = -1;
    IM_ASSERT(column_n >= -1 && column_n < table->ColumnsCount);
    if (table->Flags & (ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Hideable))
    {
        table->IsContextPopupOpen = true;
        table->ContextPopupColumn = (ImGuiTableColumnIdx)column_n;
        table->InstanceInteracted = table->InstanceCurrent;
        const ImGuiID context_menu_id = ImHashStr("##ContextMenu", 0, table->ID);
        OpenPopupEx(context_menu_id, ImGuiPopupFlags_None);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0xe3bde(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0x12f392
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
je 0x12f392
movq -0x18(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jne 0x12f3a5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpl $-0x1, -0x4(%rbp)
movb %al, -0x1d(%rbp)
jl 0x12f3c0
movl -0x4(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x12f3c9
jmp 0x12f3cb
jmp 0x12f3ea
leaq 0x5df41(%rip), %rdi     # 0x18d313
leaq 0x5cbc9(%rip), %rsi     # 0x18bfa2
movl $0xb4f, %edx            # imm = 0xB4F
leaq 0x5df5f(%rip), %rcx     # 0x18d344
callq 0xd180
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x12f446
movq -0x18(%rbp), %rax
movb $0x1, 0x24d(%rax)
movl -0x4(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x23f(%rax)
movq -0x18(%rbp), %rax
movw 0x78(%rax), %cx
movq -0x18(%rbp), %rax
movw %cx, 0x7a(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq 0x5ce9a(%rip), %rdi     # 0x18c2ca
xorl %eax, %eax
movl %eax, %esi
callq 0xc4f20
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
xorl %esi, %esi
callq 0xdde50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetColumnName(int)
const char* ImGui::TableGetColumnName(int column_n)
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return NULL;
    if (column_n < 0)
        column_n = table->CurrentColumn;
    return TableGetColumnName(table, column_n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
leaq 0xe1ede(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x131089
movq $0x0, -0x8(%rbp)
jmp 0x1310a9
cmpl $0x0, -0xc(%rbp)
jge 0x131099
movq -0x20(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1310c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetColumnName(ImGuiTable const*, int)
const char* ImGui::TableGetColumnName(const ImGuiTable* table, int column_n)
{
    if (table->IsLayoutLocked == false && column_n >= table->DeclColumnsCount)
        return ""; // NameOffset is invalid at this point
    const ImGuiTableColumn* column = &table->Columns[column_n];
    if (column->NameOffset == -1)
        return "";
    return &table->ColumnsNames.Buf[column->NameOffset];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movb 0x248(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x131102
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl 0x233(%rcx), %ecx
cmpl %ecx, %eax
jl 0x131102
leaq 0x40e0d(%rip), %rax     # 0x171f09
movq %rax, -0x8(%rbp)
jmp 0x13114c
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movl -0x14(%rbp), %esi
callq 0x1373f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movswl 0x50(%rax), %eax
cmpl $-0x1, %eax
jne 0x131130
leaq 0x40ddf(%rip), %rax     # 0x171f09
movq %rax, -0x8(%rbp)
jmp 0x13114c
movq -0x10(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movq -0x20(%rbp), %rax
movswl 0x50(%rax), %esi
callq 0x137470
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetColumnFlags(int)
ImGuiTableColumnFlags ImGui::TableGetColumnFlags(int column_n)
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return ImGuiTableColumnFlags_None;
    if (column_n < 0)
        column_n = table->CurrentColumn;
    if (column_n == table->ColumnsCount)
        return (table->HoveredColumnBody == column_n) ? ImGuiTableColumnFlags_IsHovered : ImGuiTableColumnFlags_None;
    return table->Columns[column_n].Flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
leaq 0xe1dce(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x131198
movl $0x0, -0x4(%rbp)
jmp 0x1311e8
cmpl $0x0, -0x8(%rbp)
jge 0x1311a8
movq -0x18(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jne 0x1311d3
movq -0x18(%rbp), %rax
movsbl 0x234(%rax), %edx
movl -0x8(%rbp), %esi
xorl %eax, %eax
movl $0x800000, %ecx         # imm = 0x800000
cmpl %esi, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1311e8
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movl -0x8(%rbp), %esi
callq 0xeea20
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetCellBgRect(ImGuiTable const*, int)
ImRect ImGui::TableGetCellBgRect(const ImGuiTable* table, int column_n)
{
    const ImGuiTableColumn* column = &table->Columns[column_n];
    float x1 = column->MinX;
    float x2 = column->MaxX;
    if (column->PrevEnabledColumn == -1)
        x1 -= table->CellSpacingX1;
    if (column->NextEnabledColumn == -1)
        x2 += table->CellSpacingX2;
    return ImRect(x1, table->RowPosY1, x2, table->RowPosY2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movl -0x1c(%rbp), %esi
callq 0x1373f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl 0x54(%rax), %eax
cmpl $-0x1, %eax
jne 0x131266
movq -0x18(%rbp), %rax
movss 0xc4(%rax), %xmm1
movss -0x2c(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movsbl 0x55(%rax), %eax
cmpl $-0x1, %eax
jne 0x131289
movq -0x18(%rbp), %rax
movss 0xc8(%rax), %xmm0
addss -0x30(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x2c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss -0x30(%rbp), %xmm2
movss 0x7c(%rax), %xmm1
movss 0x80(%rax), %xmm3
leaq -0x10(%rbp), %rdi
callq 0xec090
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetHoveredColumn()
int ImGui::TableGetHoveredColumn()
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return -1;
    return (int)table->HoveredColumnBody;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe1c75(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1312f1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1312ff
movq -0x18(%rbp), %rax
movsbl 0x234(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetRowIndex()
int ImGui::TableGetRowIndex()
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return 0;
    return table->CurrentRow;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe1a45(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x131521
movl $0x0, -0x4(%rbp)
jmp 0x13152b
movq -0x18(%rbp), %rax
movl 0x70(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableNextRow(int, float)
void ImGui::TableNextRow(ImGuiTableRowFlags row_flags, float row_min_height)
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;

    if (!table->IsLayoutLocked)
        TableUpdateLayout(table);
    if (table->IsInsideRow)
        TableEndRow(table);

    table->LastRowFlags = table->RowFlags;
    table->RowFlags = row_flags;
    table->RowMinHeight = row_min_height;
    TableBeginRow(table);

    // We honor min_row_height requested by user, but cannot guarantee per-row maximum height,
    // because that would essentially require a unique clipping rectangle per-cell.
    table->RowPosY2 += table->CellPaddingY * 2.0f;
    table->RowPosY2 = ImMax(table->RowPosY2, table->RowPosY1 + row_min_height);

    // Disable output until user calls TableNextColumn()
    table->InnerWindow->SkipItems = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
leaq 0xe19f9(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x248(%rax)
jne 0x131573
movq -0x18(%rbp), %rdi
callq 0x12b270
movq -0x18(%rbp), %rax
testb $0x1, 0x249(%rax)
je 0x131589
movq -0x18(%rbp), %rdi
callq 0x12e9d0
movq -0x18(%rbp), %rax
movl 0x90(%rax), %edx
shll $0x10, %edx
sarl $0x10, %edx
movq -0x18(%rbp), %rax
movl 0x90(%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
shll $0x10, %edx
andl $0xffff, %ecx           # imm = 0xFFFF
orl %edx, %ecx
movl %ecx, 0x90(%rax)
movl -0x4(%rbp), %edx
movq -0x18(%rbp), %rax
movl 0x90(%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, 0x90(%rax)
movss -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x84(%rax)
movq -0x18(%rbp), %rdi
callq 0x131660
movq -0x18(%rbp), %rax
movss 0xc0(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x80(%rax), %xmm1
addss %xmm0, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x80(%rax)
movq -0x18(%rbp), %rax
movss 0x80(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x7c(%rax), %xmm1
addss -0x8(%rbp), %xmm1
callq 0x12a620
movq -0x18(%rbp), %rax
movss %xmm0, 0x80(%rax)
movq -0x18(%rbp), %rax
movq 0x1d0(%rax), %rax
movb $0x1, 0x93(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableEndCell(ImGuiTable*)
void ImGui::TableEndCell(ImGuiTable* table)
{
    ImGuiTableColumn* column = &table->Columns[table->CurrentColumn];
    ImGuiWindow* window = table->InnerWindow;

    // Report maximum position so we can infer content size per column.
    float* p_max_pos_x;
    if (table->RowFlags & ImGuiTableRowFlags_Headers)
        p_max_pos_x = &column->ContentMaxXHeadersUsed;  // Useful in case user submit contents in header row that is not a TableHeader() call
    else
        p_max_pos_x = table->IsUnfrozenRows ? &column->ContentMaxXUnfrozen : &column->ContentMaxXFrozen;
    *p_max_pos_x = ImMax(*p_max_pos_x, window->DC.CursorMaxPos.x);
    table->RowPosY2 = ImMax(table->RowPosY2, window->DC.CursorMaxPos.y + table->CellPaddingY);
    column->ItemWidth = window->DC.ItemWidth;

    // Propagate text baseline for the entire row
    // FIXME-TABLE: Here we propagate text baseline from the last line of the cell.. instead of the first one.
    table->RowTextBaseline = ImMax(table->RowTextBaseline, window->DC.PrevLineTextBaseOffset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rax
movl 0x74(%rax), %esi
callq 0xeea20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
shll $0x10, %eax
sarl $0x10, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x131869
movq -0x10(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x20(%rbp)
jmp 0x131898
movq -0x8(%rbp), %rax
testb $0x1, 0x253(%rax)
je 0x131884
movq -0x10(%rbp), %rax
addq $0x44, %rax
movq %rax, -0x28(%rbp)
jmp 0x131890
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0xf0(%rax), %xmm1
callq 0x12a620
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movq -0x8(%rbp), %rax
movss 0x80(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0xf4(%rax), %xmm1
movq -0x8(%rbp), %rax
addss 0xc0(%rax), %xmm1
callq 0x12a620
movq -0x8(%rbp), %rax
movss %xmm0, 0x80(%rax)
movq -0x18(%rbp), %rax
movss 0x1d0(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movss 0x88(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x114(%rax), %xmm1
callq 0x12a620
movq -0x8(%rbp), %rax
movss %xmm0, 0x88(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)