user: 提供的汇编代码用C语言表示会是什么样子：

```asm
<scale_internal_int>:
  endbr64
  push   %r15
  mov    %edi,%r10d
  mov    %esi,%eax
  lea    (%r8,%r8,1),%esi
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %edx,%ebx
  sub    $0xe8,%rsp
  mov    0x120(%rsp),%rdi
  mov    %edx,0x80(%rsp)
  mov    %rcx,0x20(%rsp)
  movslq 0x128(%rsp),%r14
  mov    %rdi,0x98(%rsp)
  mov    0x130(%rsp),%edi
  mov    %r8d,0x4c(%rsp)
  mov    0x140(%rsp),%ebp
  mov    %edi,0x84(%rsp)
  mov    0x138(%rsp),%edi
  mov    %r9d,0x94(%rsp)
  mov    %edi,0x50(%rsp)
  mov    %fs:0x28,%rdx
  mov    %rdx,0xd8(%rsp)
  xor    %edx,%edx
  cmp    %eax,%esi
  jne    L141
  lea    (%r9,%r9,1),%edx
  cmp    %ebx,%edx
  je     L61
L141:
  pxor   %xmm4,%xmm4
  pxor   %xmm0,%xmm0
  mov    0x4c(%rsp),%ebx
  pxor   %xmm1,%xmm1
  mov    0x94(%rsp),%r13d
  cvtsi2ss %eax,%xmm1
  mov    %r10d,0x1c(%rsp)
  cvtsi2ssl 0x80(%rsp),%xmm4
  cvtsi2ss %r13d,%xmm0
  divss  %xmm0,%xmm4
  pxor   %xmm0,%xmm0
  cvtsi2ss %ebx,%xmm0
  divss  %xmm0,%xmm1
  movaps %xmm4,%xmm0
  movss  %xmm4,(%rsp)
  movss  %xmm1,0x18(%rsp)
  call   <floor@plt>
  pxor   %xmm0,%xmm0
  movss  (%rsp),%xmm4
  movss  0x18(%rsp),%xmm1
  cvtsi2ss %eax,%xmm0
  mov    %eax,0xb0(%rsp)
  mov    %eax,%r15d
  movaps %xmm4,%xmm8
  movss  %xmm4,0x10(%rsp)
  movss  %xmm1,(%rsp)
  subss  %xmm0,%xmm8
  movaps %xmm1,%xmm0
  movss  %xmm8,0xc(%rsp)
  call   <floor@plt>
  pxor   %xmm0,%xmm0
  movss  (%rsp),%xmm1
  movss  0x10(%rsp),%xmm4
  cvtsi2ss %eax,%xmm0
  mov    %eax,0x54(%rsp)
  mulss  %xmm1,%xmm4
  movaps %xmm1,%xmm9
  subss  %xmm0,%xmm9
  test   %r13d,%r13d
  jle    L654
  movslq 0x1c(%rsp),%rax
  mov    0x80(%rsp),%edi
  lea    0xc0(%rsp),%r12
  movl   $0x0,0x90(%rsp)
  movss  0xc(%rsp),%xmm8
  movl   $0x0,0x68(%rsp)
  pxor   %xmm6,%xmm6
  mov    %r12,%r13
  imul   %eax,%ebx
  mov    %rax,%r10
  shl    $0x2,%rax
  sub    $0x1,%edi
  mov    %rax,0x78(%rsp)
  lea    -0x1(%r10),%eax
  movaps %xmm8,%xmm3
  movss  D9(%rip),%xmm5
  lea    0x0(,%rax,4),%rdx
  add    $0x1,%rax
  mov    %edi,0xbc(%rsp)
  movaps %xmm6,%xmm7
  imul   %r14,%rax
  movslq 0x84(%rsp),%rdi
  movl   $0x0,0x6c(%rsp)
  mov    %ebx,0xb8(%rsp)
  lea    (%r12,%rdx,1),%rbx
  mov    %rdi,0x10(%rsp)
  mov    %rax,0x30(%rsp)
  mov    %r15d,%eax
  movslq 0x50(%rsp),%r15
  mov    %rbx,0x38(%rsp)
  lea    0xc4(%rsp,%rdx,1),%rbx
  mov    %r15,%r9
  mov    %r10d,%r15d
L446:
  cmp    %eax,0x80(%rsp)
  cmovle 0xbc(%rsp),%eax
  mov    %eax,0xc(%rsp)
  mov    0x4c(%rsp),%eax
  test   %eax,%eax
  jle    L929
  mov    0x68(%rsp),%edi
  mov    0x54(%rsp),%r11d
  movl   $0x0,(%rsp)
  movaps %xmm9,%xmm2
  mov    0x84(%rsp),%esi
  movl   $0x0,0x1c(%rsp)
  movaps %xmm6,%xmm12
  mov    %edi,%eax
  mov    %r11d,%r12d
  imul   %esi,%eax
  movslq %eax,%rcx
  add    %esi,%eax
  mov    %rcx,0x60(%rsp)
  lea    0x1(%rdi),%ecx
  cltq
  mov    %ecx,0x48(%rsp)
  mov    %esi,%ecx
  mov    0xc(%rsp),%esi
  add    %r9,%rax
  mov    %rax,0x70(%rsp)
  mov    %esi,%eax
  imul   %ecx,%eax
  mov    0x98(%rsp),%rcx
  cmp    %edi,%esi
  setg   0xb7(%rsp)
  cltq
  mov    %rax,0xa0(%rsp)
  movslq 0x90(%rsp),%rax
  lea    (%rcx,%rax,4),%rax
  mov    %rax,0x40(%rsp)
  mov    $0xfffffffe,%eax
  sub    %edi,%eax
  add    %esi,%eax
  mov    %eax,%eax
  add    $0x1,%rax
  imul   0x10(%rsp),%rax
  mov    %rax,0xa8(%rsp)
L804:
  mov    0x50(%rsp),%eax
  mov    (%rsp),%edi
  movq   $0x0,0xc0(%rsp)
  mov    0x60(%rsp),%rsi
  movq   $0x0,0xc8(%rsp)
  imul   %edi,%eax
  cltq
  add    %rax,%rsi
  mov    %rax,0x28(%rsp)
  add    0x20(%rsp),%rsi
  cmp    %r12d,%edi
  jge    L81
  cmpb   $0x0,0xb7(%rsp)
  jne    L662
L81:
  mov    0x68(%rsp),%edi
  cmp    %edi,0xc(%rsp)
  jg     L186
  movaps %xmm3,%xmm10
  subss  %xmm7,%xmm10
  cmp    %r12d,(%rsp)
  jge    L259
  movaps %xmm5,%xmm11
  subss  %xmm12,%xmm11
  mulss  %xmm10,%xmm11
  test   %r15d,%r15d
  jle    L342
  mov    %rsi,%rax
  mov    0x38(%rsp),%rdi
  mov    %r13,%rdx
  movaps %xmm6,%xmm0
  mov    (%rax),%r8d
  test   %ebp,%ebp
  je     L843
L703:
  mov    0xc(%rax),%ecx
  mov    0x8(%rax),%r10d
  pxor   %xmm1,%xmm1
  shl    $0x18,%ecx
  shl    $0x10,%r10d
  or     %r10d,%ecx
  or     %r8d,%ecx
  mov    0x4(%rax),%r8d
  add    %r14,%rax
  shl    $0x8,%r8d
  or     %r8d,%ecx
  cvtsi2ss %ecx,%xmm1
  mulss  %xmm11,%xmm1
  addss  %xmm1,%xmm0
  movss  %xmm0,(%rdx)
  cmp    %rdi,%rdx
  je     L342
L436:
  movss  0x4(%rdx),%xmm0
  mov    (%rax),%r8d
  add    $0x4,%rdx
  test   %ebp,%ebp
  jne    L703
L843:
  pxor   %xmm1,%xmm1
  add    %r14,%rax
  cvtsi2ss %r8d,%xmm1
  mulss  %xmm11,%xmm1
  addss  %xmm1,%xmm0
  movss  %xmm0,(%rdx)
  cmp    %rdi,%rdx
  jne    L436
L342:
  mov    (%rsp),%eax
  lea    0x1(%rax),%r10d
  cmp    %r12d,%r10d
  jge    L355
  mov    %rsi,%r11
L148:
  add    %r9,%r11
  mov    %r13,%rax
  mov    %r11,%rcx
  test   %r15d,%r15d
  jle    L86
  nopl   0x0(%rax,%rax,1)
L1003:
  movss  (%rax),%xmm0
  mov    (%rcx),%edi
  test   %ebp,%ebp
  je     L522
  mov    0xc(%rcx),%edx
  mov    0x8(%rcx),%r8d
  pxor   %xmm1,%xmm1
  shl    $0x18,%edx
  shl    $0x10,%r8d
  or     %r8d,%edx
  or     %edi,%edx
  mov    0x4(%rcx),%edi
  shl    $0x8,%edi
  or     %edi,%edx
  cvtsi2ss %edx,%xmm1
  mulss  %xmm10,%xmm1
  addss  %xmm1,%xmm0
L376:
  movss  %xmm0,(%rax)
  add    $0x4,%rax
  add    %r14,%rcx
  cmp    %rax,%rbx
  jne    L1003
L86:
  add    $0x1,%r10d
  cmp    %r12d,%r10d
  jne    L148
  lea    -0x2(%r12),%eax
  sub    (%rsp),%eax
  add    $0x1,%rax
  imul   %r9,%rax
  add    %rax,%rsi
L355:
  mulss  %xmm2,%xmm10
  add    %r9,%rsi
  test   %r15d,%r15d
  jle    L538
  mov    %r13,%rax
L112:
  movss  (%rax),%xmm0
  mov    (%rsi),%ecx
  test   %ebp,%ebp
  je     L844
  mov    0xc(%rsi),%edx
  mov    0x8(%rsi),%edi
  pxor   %xmm1,%xmm1
  shl    $0x18,%edx
  shl    $0x10,%edi
  or     %edi,%edx
  or     %ecx,%edx
  mov    0x4(%rsi),%ecx
  shl    $0x8,%ecx
  or     %ecx,%edx
  cvtsi2ss %edx,%xmm1
  mulss  %xmm10,%xmm1
  addss  %xmm1,%xmm0
L821:
  movss  %xmm0,(%rax)
  add    $0x4,%rax
  add    %r14,%rsi
  cmp    %rbx,%rax
  jne    L112
L228:
  mov    0x28(%rsp),%r11
  mov    0xc(%rsp),%edi
  add    0x70(%rsp),%r11
  add    0x20(%rsp),%r11
  cmp    %edi,0x48(%rsp)
  jge    L595
L812:
  mov    (%rsp),%eax
  add    $0x1,%eax
  mov    %eax,0x18(%rsp)
L521:
  mov    0x48(%rsp),%eax
  mov    %eax,(%rsp)
  nop
L736:
  mov    0x18(%rsp),%eax
  mov    %r11,%r8
  mov    %eax,%r10d
  cmp    %r12d,%eax
  jge    L325
  nop
L333:
  mov    %r13,%rax
  mov    %r8,%rcx
  test   %r15d,%r15d
  jle    L203
L772:
  movss  (%rax),%xmm0
  mov    (%rcx),%esi
  test   %ebp,%ebp
  je     L444
  mov    0xc(%rcx),%edx
  mov    0x8(%rcx),%edi
  pxor   %xmm1,%xmm1
  shl    $0x18,%edx
  shl    $0x10,%edi
  or     %edi,%edx
  or     %esi,%edx
  mov    0x4(%rcx),%esi
  shl    $0x8,%esi
  or     %esi,%edx
  cvtsi2ss %edx,%xmm1
  addss  %xmm1,%xmm0
L42:
  movss  %xmm0,(%rax)
  add    $0x4,%rax
  add    %r14,%rcx
  cmp    %rbx,%rax
  jne    L772
L203:
  add    $0x1,%r10d
  add    %r9,%r8
  cmp    %r12d,%r10d
  jne    L333
L325:
  addl   $0x1,(%rsp)
  add    0x10(%rsp),%r11
  mov    (%rsp),%eax
  cmp    %eax,0xc(%rsp)
  jg     L736
  test   %r15d,%r15d
  jle    L409
L595:
  mov    0x40(%rsp),%rcx
  xor    %eax,%eax
L890:
  movss  0x0(%r13,%rax,4),%xmm0
  divss  %xmm4,%xmm0
  cvttss2si %xmm0,%edx
  mov    %edx,(%rcx,%rax,4)
  add    $0x1,%rax
  cmp    %eax,%r15d
  jg     L890
L409:
  movaps %xmm9,%xmm0
  mov    0x54(%rsp),%eax
  addss  %xmm2,%xmm0
  add    %r12d,%eax
  comiss %xmm5,%xmm0
  jbe    L75
  subss  %xmm5,%xmm0
  add    $0x1,%eax
L75:
  addl   $0x1,0x1c(%rsp)
  mov    0x78(%rsp),%rcx
  movaps %xmm2,%xmm12
  add    %rcx,0x40(%rsp)
  mov    0x1c(%rsp),%edi
  mov    %r12d,(%rsp)
  cmp    %edi,0x4c(%rsp)
  je     L929
  movaps %xmm0,%xmm2
  mov    %eax,%r12d
  jmp    L804
  nopl   (%rax)
L444:
  pxor   %xmm1,%xmm1
  cvtsi2ss %esi,%xmm1
  addss  %xmm1,%xmm0
  jmp    L42
  nopl   0x0(%rax)
L522:
  pxor   %xmm1,%xmm1
  cvtsi2ss %edi,%xmm1
  mulss  %xmm10,%xmm1
  addss  %xmm1,%xmm0
  jmp    L376
L844:
  pxor   %xmm1,%xmm1
  cvtsi2ss %ecx,%xmm1
  mulss  %xmm10,%xmm1
  addss  %xmm1,%xmm0
  jmp    L821
L259:
  movaps %xmm2,%xmm0
  subss  %xmm12,%xmm0
  mulss  %xmm0,%xmm10
  test   %r15d,%r15d
  jle    L538
  mov    0x38(%rsp),%rcx
  mov    (%rsi),%edi
  mov    %r13,%rax
  movaps %xmm6,%xmm0
  test   %ebp,%ebp
  je     L621
L723:
  mov    0xc(%rsi),%edx
  mov    0x8(%rsi),%r8d
  pxor   %xmm1,%xmm1
  shl    $0x18,%edx
  shl    $0x10,%r8d
  or     %r8d,%edx
  or     %edi,%edx
  mov    0x4(%rsi),%edi
  shl    $0x8,%edi
  or     %edi,%edx
  cvtsi2ss %edx,%xmm1
  mulss  %xmm10,%xmm1
  addss  %xmm1,%xmm0
L696:
  movss  %xmm0,(%rax)
  add    %r14,%rsi
  cmp    %rcx,%rax
  je     L228
  movss  0x4(%rax),%xmm0
  mov    (%rsi),%edi
  add    $0x4,%rax
  test   %ebp,%ebp
  jne    L723
L621:
  pxor   %xmm1,%xmm1
  cvtsi2ss %edi,%xmm1
  mulss  %xmm10,%xmm1
  addss  %xmm1,%xmm0
  jmp    L696
L662:
  movaps %xmm5,%xmm1
  movaps %xmm5,%xmm11
  subss  %xmm12,%xmm1
  subss  %xmm7,%xmm11
  movaps %xmm1,%xmm12
  mulss  %xmm11,%xmm12
  test   %r15d,%r15d
  jle    L700
  mov    %rsi,%rax
  mov    0x38(%rsp),%rdi
  mov    %r13,%rdx
  movaps %xmm6,%xmm0
  mov    (%rax),%r8d
  test   %ebp,%ebp
  je     L674
L281:
  mov    0xc(%rax),%ecx
  mov    0x8(%rax),%r10d
  pxor   %xmm10,%xmm10
  shl    $0x18,%ecx
  shl    $0x10,%r10d
  or     %r10d,%ecx
  or     %r8d,%ecx
  mov    0x4(%rax),%r8d
  add    %r14,%rax
  shl    $0x8,%r8d
  or     %r8d,%ecx
  cvtsi2ss %ecx,%xmm10
  mulss  %xmm12,%xmm10
  addss  %xmm10,%xmm0
  movss  %xmm0,(%rdx)
  cmp    %rdi,%rdx
  je     L700
L307:
  movss  0x4(%rdx),%xmm0
  mov    (%rax),%r8d
  add    $0x4,%rdx
  test   %ebp,%ebp
  jne    L281
L674:
  pxor   %xmm10,%xmm10
  add    %r14,%rax
  cvtsi2ss %r8d,%xmm10
  mulss  %xmm12,%xmm10
  addss  %xmm10,%xmm0
  movss  %xmm0,(%rdx)
  cmp    %rdi,%rdx
  jne    L307
L700:
  mov    (%rsp),%eax
  lea    0x1(%rax),%r11d
  mov    %r11d,0x18(%rsp)
  cmp    %r12d,%r11d
  jge    L991
  mov    %rsi,%r10
L45:
  add    %r9,%r10
  mov    %r13,%rax
  mov    %r10,%rcx
  test   %r15d,%r15d
  jle    L709
L891:
  movss  (%rax),%xmm0
  mov    (%rcx),%edi
  test   %ebp,%ebp
  je     L490
  mov    0xc(%rcx),%edx
  mov    0x8(%rcx),%r8d
  pxor   %xmm10,%xmm10
  shl    $0x18,%edx
  shl    $0x10,%r8d
  or     %r8d,%edx
  or     %edi,%edx
  mov    0x4(%rcx),%edi
  shl    $0x8,%edi
  or     %edi,%edx
  cvtsi2ss %edx,%xmm10
  mulss  %xmm11,%xmm10
  addss  %xmm10,%xmm0
L680:
  movss  %xmm0,(%rax)
  add    $0x4,%rax
  add    %r14,%rcx
  cmp    %rbx,%rax
  jne    L891
L709:
  add    $0x1,%r11d
  cmp    %r12d,%r11d
  jne    L45
  lea    -0x2(%r12),%eax
  sub    (%rsp),%eax
  add    $0x1,%rax
  imul   %r9,%rax
  add    %rsi,%rax
L808:
  lea    (%rax,%r9,1),%rdx
  mov    0xa0(%rsp),%rax
  add    0x28(%rsp),%rax
  add    0x20(%rsp),%rax
  mov    %rdx,0x88(%rsp)
  mov    %rax,0x58(%rsp)
  mulss  %xmm2,%xmm11
  mov    %r13,%rax
  test   %r15d,%r15d
  jle    L932
L999:
  movss  (%rax),%xmm0
  mov    (%rdx),%edi
  test   %ebp,%ebp
  je     L122
  mov    0xc(%rdx),%ecx
  mov    0x8(%rdx),%r8d
  pxor   %xmm10,%xmm10
  shl    $0x18,%ecx
  shl    $0x10,%r8d
  or     %r8d,%ecx
  or     %edi,%ecx
  mov    0x4(%rdx),%edi
  shl    $0x8,%edi
  or     %edi,%ecx
  cvtsi2ss %ecx,%xmm10
  mulss  %xmm11,%xmm10
  addss  %xmm10,%xmm0
L92:
  movss  %xmm0,(%rax)
  add    $0x4,%rax
  add    %r14,%rdx
  cmp    %rbx,%rax
  jne    L999
  movaps %xmm1,%xmm11
  mov    0x58(%rsp),%rdx
  mov    %r13,%rax
  mulss  %xmm3,%xmm11
L610:
  movss  (%rax),%xmm0
  mov    (%rdx),%edi
  test   %ebp,%ebp
  je     L453
  mov    0xc(%rdx),%ecx
  mov    0x8(%rdx),%r8d
  pxor   %xmm10,%xmm10
  shl    $0x18,%ecx
  shl    $0x10,%r8d
  or     %r8d,%ecx
  or     %edi,%ecx
  mov    0x4(%rdx),%edi
  shl    $0x8,%edi
  or     %edi,%ecx
  cvtsi2ss %ecx,%xmm10
  mulss  %xmm11,%xmm10
  addss  %xmm10,%xmm0
L842:
  movss  %xmm0,(%rax)
  add    $0x4,%rax
  add    %r14,%rdx
  cmp    %rbx,%rax
  jne    L610
L932:
  mov    0x18(%rsp),%eax
  mov    0x58(%rsp),%r10
  mov    %eax,%r11d
  cmp    %r12d,%eax
  jge    L924
L504:
  add    %r9,%r10
  mov    %r13,%rax
  mov    %r10,%rcx
  test   %r15d,%r15d
  jle    L145
L222:
  movss  (%rax),%xmm0
  mov    (%rcx),%edi
  test   %ebp,%ebp
  je     L364
  mov    0xc(%rcx),%edx
  mov    0x8(%rcx),%r8d
  pxor   %xmm10,%xmm10
  shl    $0x18,%edx
  shl    $0x10,%r8d
  or     %r8d,%edx
  or     %edi,%edx
  mov    0x4(%rcx),%edi
  shl    $0x8,%edi
  or     %edi,%edx
  cvtsi2ss %edx,%xmm10
  mulss  %xmm3,%xmm10
  addss  %xmm10,%xmm0
L289:
  movss  %xmm0,(%rax)
  add    $0x4,%rax
  add    %r14,%rcx
  cmp    %rbx,%rax
  jne    L222
L145:
  add    $0x1,%r11d
  cmp    %r12d,%r11d
  jne    L504
  lea    -0x2(%r12),%eax
  sub    (%rsp),%eax
  add    $0x1,%rax
  imul   %r9,%rax
  add    %rax,0x58(%rsp)
L924:
  mov    0x58(%rsp),%rdx
  movaps %xmm2,%xmm11
  mulss  %xmm3,%xmm11
  add    %r9,%rdx
  test   %r15d,%r15d
  jle    L24
  mov    %r13,%rax
L739:
  movss  (%rax),%xmm0
  mov    (%rdx),%edi
  test   %ebp,%ebp
  je     L106
  mov    0xc(%rdx),%ecx
  mov    0x8(%rdx),%r8d
  pxor   %xmm10,%xmm10
  shl    $0x18,%ecx
  shl    $0x10,%r8d
  or     %r8d,%ecx
  or     %edi,%ecx
  mov    0x4(%rdx),%edi
  shl    $0x8,%edi
  or     %edi,%ecx
  cvtsi2ss %ecx,%xmm10
  mulss  %xmm11,%xmm10
  addss  %xmm10,%xmm0
L88:
  movss  %xmm0,(%rax)
  add    $0x4,%rax
  add    %r14,%rdx
  cmp    %rbx,%rax
  jne    L739
  mov    0x48(%rsp),%eax
  mov    %eax,%ecx
  cmp    0xc(%rsp),%eax
  jge    L595
L57:
  mov    0x88(%rsp),%r11
  mov    %r9,0x88(%rsp)
  mov    %r13,(%rsp)
  mov    0x10(%rsp),%r13
  mov    %r12d,0x58(%rsp)
  mov    %ecx,%r12d
L251:
  add    %r13,%rsi
  add    %r13,%r11
  test   %r15d,%r15d
  jle    L910
  mov    (%rsp),%rax
  mov    %r11,%rdi
  mov    %rsi,%rcx
L694:
  movss  (%rax),%xmm10
  mov    (%rcx),%r9d
  mov    (%rdi),%r8d
  test   %ebp,%ebp
  je     L220
  mov    0xc(%rcx),%edx
  mov    0x8(%rcx),%r10d
  pxor   %xmm0,%xmm0
  shl    $0x18,%edx
  shl    $0x10,%r10d
  or     %r10d,%edx
  or     %r9d,%edx
  mov    0x4(%rcx),%r9d
  shl    $0x8,%r9d
  or     %r9d,%edx
  mov    0x8(%rdi),%r9d
  cvtsi2ss %edx,%xmm0
  mov    0xc(%rdi),%edx
  shl    $0x10,%r9d
  shl    $0x18,%edx
  or     %r9d,%edx
  mulss  %xmm1,%xmm0
  or     %r8d,%edx
  mov    0x4(%rdi),%r8d
  shl    $0x8,%r8d
  or     %r8d,%edx
  addss  %xmm10,%xmm0
  pxor   %xmm10,%xmm10
  cvtsi2ss %edx,%xmm10
  mulss  %xmm2,%xmm10
  addss  %xmm0,%xmm10
L422:
  movss  %xmm10,(%rax)
  add    $0x4,%rax
  add    %r14,%rcx
  add    %r14,%rdi
  cmp    %rbx,%rax
  jne    L694
  mov    0x30(%rsp),%rax
  add    %rax,%rsi
  add    %rax,%r11
L910:
  add    $0x1,%r12d
  cmp    %r12d,0xc(%rsp)
  jne    L251
  mov    0x28(%rsp),%r11
  mov    0x58(%rsp),%r12d
  add    0x70(%rsp),%r11
  mov    (%rsp),%r13
  mov    0x88(%rsp),%r9
  add    0x20(%rsp),%r11
  jmp    L521
  nopl   0x0(%rax)
L220:
  pxor   %xmm0,%xmm0
  pxor   %xmm11,%xmm11
  cvtsi2ss %r9d,%xmm0
  cvtsi2ss %r8d,%xmm11
  mulss  %xmm1,%xmm0
  mulss  %xmm2,%xmm11
  addss  %xmm11,%xmm0
  addss  %xmm0,%xmm10
  jmp    L422
  nopl   0x0(%rax,%rax,1)
L364:
  pxor   %xmm10,%xmm10
  cvtsi2ss %edi,%xmm10
  mulss  %xmm3,%xmm10
  addss  %xmm10,%xmm0
  jmp    L289
  nopl   0x0(%rax)
L490:
  pxor   %xmm10,%xmm10
  cvtsi2ss %edi,%xmm10
  mulss  %xmm11,%xmm10
  addss  %xmm10,%xmm0
  jmp    L680
L453:
  pxor   %xmm10,%xmm10
  cvtsi2ss %edi,%xmm10
  mulss  %xmm11,%xmm10
  addss  %xmm10,%xmm0
  jmp    L842
L106:
  pxor   %xmm10,%xmm10
  cvtsi2ss %edi,%xmm10
  mulss  %xmm11,%xmm10
  addss  %xmm10,%xmm0
  jmp    L88
L122:
  pxor   %xmm10,%xmm10
  cvtsi2ss %edi,%xmm10
  mulss  %xmm11,%xmm10
  addss  %xmm10,%xmm0
  jmp    L92
L186:
  movaps %xmm2,%xmm10
  movaps %xmm5,%xmm11
  subss  %xmm12,%xmm10
  subss  %xmm7,%xmm11
  mulss  %xmm10,%xmm11
  test   %r15d,%r15d
  jle    L287
  mov    %rsi,%rax
  mov    %r13,%r8
  movaps %xmm6,%xmm0
  mov    (%rax),%ecx
  test   %ebp,%ebp
  je     L1002
L279:
  mov    0xc(%rax),%edx
  mov    0x8(%rax),%edi
  pxor   %xmm1,%xmm1
  shl    $0x18,%edx
  shl    $0x10,%edi
  or     %edi,%edx
  or     %ecx,%edx
  mov    0x4(%rax),%ecx
  add    %r14,%rax
  shl    $0x8,%ecx
  or     %ecx,%edx
  cvtsi2ss %edx,%xmm1
  mulss  %xmm11,%xmm1
  addss  %xmm1,%xmm0
  movss  %xmm0,(%r8)
  cmp    0x38(%rsp),%r8
  je     L287
L115:
  movss  0x4(%r8),%xmm0
  mov    (%rax),%ecx
  add    $0x4,%r8
  test   %ebp,%ebp
  jne    L279
L1002:
  pxor   %xmm1,%xmm1
  add    %r14,%rax
  cvtsi2ss %ecx,%xmm1
  mulss  %xmm11,%xmm1
  addss  %xmm1,%xmm0
  movss  %xmm0,(%r8)
  cmp    0x38(%rsp),%r8
  jne    L115
L287:
  mov    0x48(%rsp),%eax
  mov    %eax,%r10d
  cmp    %eax,0xc(%rsp)
  jle    L264
  mov    %rsi,%r11
L927:
  add    0x10(%rsp),%r11
  mov    %r13,%rax
  mov    %r11,%rcx
  test   %r15d,%r15d
  jle    L510
L194:
  movss  (%rax),%xmm0
  mov    (%rcx),%edi
  test   %ebp,%ebp
  je     L493
  mov    0xc(%rcx),%edx
  mov    0x8(%rcx),%r8d
  pxor   %xmm1,%xmm1
  shl    $0x18,%edx
  shl    $0x10,%r8d
  or     %r8d,%edx
  or     %edi,%edx
  mov    0x4(%rcx),%edi
  shl    $0x8,%edi
  or     %edi,%edx
  cvtsi2ss %edx,%xmm1
  mulss  %xmm10,%xmm1
  addss  %xmm1,%xmm0
L783:
  movss  %xmm0,(%rax)
  add    $0x4,%rax
  add    %r14,%rcx
  cmp    %rbx,%rax
  jne    L194
L510:
  add    $0x1,%r10d
  cmp    %r10d,0xc(%rsp)
  jne    L927
  add    0xa8(%rsp),%rsi
L264:
  mulss  %xmm3,%xmm10
  add    0x10(%rsp),%rsi
  test   %r15d,%r15d
  jle    L538
  mov    %r13,%rdi
  mov    (%rsi),%edx
  movss  (%rdi),%xmm0
  test   %ebp,%ebp
  je     L294
L309:
  mov    0xc(%rsi),%eax
  mov    0x8(%rsi),%ecx
  pxor   %xmm1,%xmm1
  shl    $0x18,%eax
  shl    $0x10,%ecx
  or     %ecx,%eax
  or     %edx,%eax
  mov    0x4(%rsi),%edx
  shl    $0x8,%edx
  or     %edx,%eax
  cvtsi2ss %eax,%xmm1
  mulss  %xmm10,%xmm1
  addss  %xmm1,%xmm0
L550:
  movss  %xmm0,(%rdi)
  add    $0x4,%rdi
  add    %r14,%rsi
  cmp    %rbx,%rdi
  je     L228
  movss  (%rdi),%xmm0
  mov    (%rsi),%edx
  test   %ebp,%ebp
  jne    L309
L294:
  pxor   %xmm1,%xmm1
  cvtsi2ss %edx,%xmm1
  mulss  %xmm10,%xmm1
  addss  %xmm1,%xmm0
  jmp    L550
L493:
  pxor   %xmm1,%xmm1
  cvtsi2ss %edi,%xmm1
  mulss  %xmm10,%xmm1
  addss  %xmm1,%xmm0
  jmp    L783
L929:
  movaps %xmm8,%xmm0
  mov    0xc(%rsp),%eax
  add    0xb0(%rsp),%eax
  addss  %xmm3,%xmm0
  comiss %xmm5,%xmm0
  jbe    L93
  subss  %xmm5,%xmm0
  add    $0x1,%eax
L93:
  addl   $0x1,0x6c(%rsp)
  mov    0xb8(%rsp),%ecx
  movaps %xmm3,%xmm7
  add    %ecx,0x90(%rsp)
  mov    0x6c(%rsp),%edi
  cmp    %edi,0x94(%rsp)
  je     L654
  mov    0xc(%rsp),%edi
  movaps %xmm0,%xmm3
  mov    %edi,0x68(%rsp)
  jmp    L446
L538:
  mov    0x28(%rsp),%r11
  mov    0xc(%rsp),%edi
  add    0x70(%rsp),%r11
  add    0x20(%rsp),%r11
  cmp    %edi,0x48(%rsp)
  jl     L812
  jmp    L409
L24:
  mov    0x48(%rsp),%eax
  mov    %eax,%ecx
  cmp    %eax,0xc(%rsp)
  jg     L57
  jmp    L409
L991:
  mov    %rsi,%rax
  jmp    L808
L654:
  mov    0xd8(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L983
  add    $0xe8,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L61:
  mov    0xd8(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L983
  mov    0x50(%rsp),%eax
  mov    0x20(%rsp),%rcx
  mov    %r14d,%r9d
  mov    %r10d,%edi
  mov    %ebp,0x130(%rsp)
  mov    0x98(%rsp),%r8
  mov    %eax,0x128(%rsp)
  mov    0x84(%rsp),%eax
  mov    %eax,0x120(%rsp)
  add    $0xe8,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  jmp    1080 <halveImage_int@plt>
L983:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: label: D9
datatype: f32

tool: D9: 1

assistant: ```c
void scale_internal_int(GLint components, GLint widthin, GLint heightin, const GLint *datain, GLint widthout, GLint heightout, GLint *dataout, GLint element_size, GLint ysize, GLint group_size, GLint myswap_bytes) {
  float convx;
  float convy;
  float percent;
  float totals[4];
  float area;
  int i, j, k, xindex;
  const char *temp, *temp0;
  const char *temp_index;
  int outindex;
  int lowx_int, highx_int, lowy_int, highy_int;
  float x_percent, y_percent;
  float lowx_float, highx_float, lowy_float, highy_float;
  float convy_float, convx_float;
  int convy_int, convx_int;
  int l, m;
  const char *left, *right;
  GLuint swapbuf;
  if (widthin == widthout * 2 && heightin == heightout * 2) {
    halveImage_int(components, widthin, heightin, (const GLint *)datain, (GLint *)dataout, element_size, ysize, group_size, myswap_bytes);
    return;
  }
  convy = (float)heightin / heightout;
  convx = (float)widthin / widthout;
  convy_int = floor(convy);
  convy_float = convy - convy_int;
  convx_int = floor(convx);
  convx_float = convx - convx_int;
  area = convx * convy;
  lowy_int = 0;
  lowy_float = 0;
  highy_int = convy_int;
  highy_float = convy_float;
  for (i = 0; i < heightout; i++) {
    if (highy_int >= heightin)
      highy_int = heightin - 1;
    lowx_int = 0;
    lowx_float = 0;
    highx_int = convx_int;
    highx_float = convx_float;
    for (j = 0; j < widthout; j++) {
      totals[0] = totals[1] = totals[2] = totals[3] = 0.0;
      xindex = lowx_int * group_size;
      if ((highy_int > lowy_int) && (highx_int > lowx_int)) {
        y_percent = 1 - lowy_float;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        percent = y_percent * (1 - lowx_float);
        for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)temp_index * percent;
          }
        }
        left = temp;
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
              totals[k] += *(const GLint *)&swapbuf * y_percent;
            } else {
              totals[k] += *(const GLint *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        right = temp;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)temp_index * percent;
          }
        }
        y_percent = highy_float;
        percent = y_percent * (1 - lowx_float);
        temp = (const char *)datain + xindex + highy_int * ysize;
        for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)temp_index * percent;
          }
        }
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
              totals[k] += *(const GLint *)&swapbuf * y_percent;
            } else {
              totals[k] += *(const GLint *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)temp_index * percent;
          }
        }
        for (m = lowy_int + 1; m < highy_int; m++) {
          left += ysize;
          right += ysize;
          for (k = 0; k < components; k++, left += element_size, right += element_size) {
            if (myswap_bytes) {
              swapbuf = (GLuint)(((GLuint)((const GLubyte *)(left))[3]) << 24 | ((GLuint)((const GLubyte *)(left))[2]) << 16 | ((GLuint)((const GLubyte *)(left))[1]) << 8 | ((const GLubyte *)(left))[0]);
              totals[k] += *(const GLint *)&swapbuf * (1 - lowx_float);
              swapbuf = (GLuint)(((GLuint)((const GLubyte *)(right))[3]) << 24 | ((GLuint)((const GLubyte *)(right))[2]) << 16 | ((GLuint)((const GLubyte *)(right))[1]) << 8 | ((const GLubyte *)(right))[0]);
              totals[k] += *(const GLint *)&swapbuf * highx_float;
            } else {
              totals[k] += *(const GLint *)left * (1 - lowx_float) + *(const GLint *)right * highx_float;
            }
          }
        }
      } else if (highy_int > lowy_int) {
        x_percent = highx_float - lowx_float;
        percent = (1 - lowy_float) * x_percent;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)temp_index * percent;
          }
        }
        for (m = lowy_int + 1; m < highy_int; m++) {
          temp += ysize;
          for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
              totals[k] += *(const GLint *)&swapbuf * x_percent;
            } else {
              totals[k] += *(const GLint *)temp_index * x_percent;
            }
          }
        }
        percent = x_percent * highy_float;
        temp += ysize;
        for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)temp_index * percent;
          }
        }
      } else if (highx_int > lowx_int) {
        y_percent = highy_float - lowy_float;
        percent = (1 - lowx_float) * y_percent;
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)temp_index * percent;
          }
        }
        for (l = lowx_int + 1; l < highx_int; l++) {
          temp += group_size;
          for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
              totals[k] += *(const GLint *)&swapbuf * y_percent;
            } else {
              totals[k] += *(const GLint *)temp_index * y_percent;
            }
          }
        }
        temp += group_size;
        percent = y_percent * highx_float;
        for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)temp_index * percent;
          }
        }
      } else {
        percent = (highy_float - lowy_float) * (highx_float - lowx_float);
        temp = (const char *)datain + xindex + lowy_int * ysize;
        for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
          if (myswap_bytes) {
            swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
            totals[k] += *(const GLint *)&swapbuf * percent;
          } else {
            totals[k] += *(const GLint *)temp_index * percent;
          }
        }
      }
      temp0 = (const char *)datain + xindex + group_size + (lowy_int + 1) * ysize;
      for (m = lowy_int + 1; m < highy_int; m++) {
        temp = temp0;
        for (l = lowx_int + 1; l < highx_int; l++) {
          for (k = 0, temp_index = temp; k < components; k++, temp_index += element_size) {
            if (myswap_bytes) {
              swapbuf = (GLuint)(((GLuint)((const GLubyte *)(temp_index))[3]) << 24 | ((GLuint)((const GLubyte *)(temp_index))[2]) << 16 | ((GLuint)((const GLubyte *)(temp_index))[1]) << 8 | ((const GLubyte *)(temp_index))[0]);
              totals[k] += *(const GLint *)&swapbuf;
            } else {
              totals[k] += *(const GLint *)temp_index;
            }
          }
          temp += group_size;
        }
        temp0 += ysize;
      }
      outindex = (j + (i * widthout)) * components;
      for (k = 0; k < components; k++) {
        dataout[outindex + k] = totals[k] / area;
      }
      lowx_int = highx_int;
      lowx_float = highx_float;
      highx_int += convx_int;
      highx_float += convx_float;
      if (highx_float > 1) {
        highx_float -= 1.0;
        highx_int++;
      }
    }
    lowy_int = highy_int;
    lowy_float = highy_float;
    highy_int += convy_int;
    highy_float += convy_float;
    if (highy_float > 1) {
      highy_float -= 1.0;
      highy_int++;
    }
  }
}
```