user: 请从给定的汇编指令推导出C源代码：

```asm
<glassofast>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  lea    -0x19a000(%rsp),%r11
L777:
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  cmp    %r11,%rsp
  jne    L777
  sub    $0x348,%rsp
  mov    0x19a380(%rsp),%rax
  mov    %rsi,0x80(%rsp)
  mov    %r8d,%r15d
  mov    0x19a388(%rsp),%r8
  mov    %rdx,0x90(%rsp)
  mov    %ecx,0x9c(%rsp)
  mov    %rax,0x58(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x19a338(%rsp)
  xor    %eax,%eax
  test   %edi,%edi
  jle    L620
  lea    -0x1(%rdi),%eax
  mov    %edi,%r10d
  pxor   %xmm2,%xmm2
  mov    %r9d,%r12d
  lea    0x0(,%rax,8),%rbp
  mov    %r10d,%ecx
  mov    %eax,0x98(%rsp)
  mov    %r10d,%eax
  shr    %eax
  lea    0x8(%rsi,%rbp,1),%rdi
  movapd %xmm2,%xmm1
  and    $0xfffffffe,%ecx
  lea    -0x1(%rax),%r11d
  mov    %ecx,0x38(%rsp)
  movq   D87(%rip),%xmm4
  mov    %r11,%rax
  movapd D106(%rip),%xmm6
  shl    $0x4,%rax
  mov    %rax,0x88(%rsp)
  lea    0x10(%rax),%r9
L451:
  mov    (%rsi),%rdx
  cmp    $0x1,%r10d
  je     L224
  mov    %rdx,%rax
  lea    (%r9,%rdx,1),%rcx
  nopw   0x0(%rax,%rax,1)
L463:
  movupd (%rax),%xmm5
  add    $0x10,%rax
  andpd  %xmm6,%xmm5
  addsd  %xmm5,%xmm1
  unpckhpd %xmm5,%xmm5
  addsd  %xmm5,%xmm1
  cmp    %rcx,%rax
  jne    L463
  movslq 0x38(%rsp),%rax
  cmp    %r10d,%eax
  je     L685
L870:
  movsd  (%rdx,%rax,8),%xmm3
  andpd  %xmm4,%xmm3
  addsd  %xmm3,%xmm1
L685:
  add    $0x8,%rsi
  cmp    %rdi,%rsi
  jne    L451
  mov    %r10d,%ebx
  mov    0x80(%rsp),%rcx
  lea    0x0(,%rbx,8),%rax
  mov    %rax,0x10(%rsp)
  xor    %eax,%eax
L54:
  mov    (%rcx,%rax,1),%rdx
  movsd  (%rdx,%rax,1),%xmm3
  add    $0x8,%rax
  andpd  %xmm4,%xmm3
  subsd  %xmm3,%xmm1
  cmp    0x10(%rsp),%rax
  jne    L54
  ucomisd %xmm2,%xmm1
  jp     L79
  je     L557
L79:
  pxor   %xmm3,%xmm3
  cvtsi2sdl 0x98(%rsp),%xmm3
  divsd  %xmm3,%xmm0
  mulsd  %xmm1,%xmm0
  movsd  %xmm0,0xa8(%rsp)
  movapd %xmm0,%xmm7
  pxor   %xmm0,%xmm0
  cvtsi2sd %r10d,%xmm0
  divsd  %xmm0,%xmm7
  movsd  D90(%rip),%xmm0
  maxsd  %xmm7,%xmm0
  movapd %xmm0,%xmm7
  test   %r12d,%r12d
  je     L439
  movslq %r10d,%rax
  movapd D17(%rip),%xmm1
  xor    %ecx,%ecx
  movq   D137(%rip),%xmm8
  lea    0x0(,%rax,8),%r12
  mov    0x38(%rsp),%eax
  lea    0x0(,%rax,8),%r9
  mov    0x88(%rsp),%rax
  lea    0x10(%rax),%rbp
L113:
  mov    0x58(%rsp),%rax
  mov    %rcx,%rdx
  mov    (%rax,%rcx,1),%rax
  lea    (%rax,%rcx,1),%rsi
  add    $0x8,%rcx
  cmp    %rdx,%r12
  jg     L724
  cmp    $0x1,%r10d
  je     L724
  movsd  (%rsi),%xmm3
  mov    %rax,%rdx
  lea    0x0(%rbp,%rax,1),%rdi
  unpcklpd %xmm3,%xmm3
L430:
  movupd (%rdx),%xmm0
  add    $0x10,%rdx
  xorpd  %xmm1,%xmm0
  divpd  %xmm3,%xmm0
  movups %xmm0,-0x10(%rdx)
  cmp    %rdi,%rdx
  jne    L430
  cmp    %r10d,0x38(%rsp)
  je     L522
  add    %r9,%rax
  movsd  (%rax),%xmm0
  xorpd  %xmm8,%xmm0
  divsd  (%rsi),%xmm0
  movsd  %xmm0,(%rax)
L522:
  movq   $0x0,(%rsi)
  cmp    0x10(%rsp),%rcx
  jne    L113
  lea    0x1(%r11),%rax
  mov    %rax,0xa0(%rsp)
L14:
  mov    0x80(%rsp),%rdi
  mov    0x90(%rsp),%r9
  xor    %eax,%eax
  lea    0xb0(%rsp),%rcx
L805:
  mov    (%r9,%rax,1),%rdx
  mov    (%rdi,%rax,1),%rsi
  movsd  (%rsi,%rax,1),%xmm0
  addsd  (%rdx,%rax,1),%xmm0
  mov    (%r8,%rax,1),%rdx
  movsd  %xmm0,(%rcx,%rax,1)
  movsd  %xmm0,(%rdx,%rax,1)
  add    $0x8,%rax
  cmp    0x10(%rsp),%rax
  jne    L805
  mov    0x9c(%rsp),%edx
  test   %edx,%edx
  jle    L191
  mov    0x88(%rsp),%rax
  lea    0xcd200(%rsp),%rdx
  mov    %r15d,%r9d
  movl   $0x1,0x7c(%rsp)
  lea    0xcd1f0(%rsp),%r13
  add    %rdx,%rax
  test   %r10d,%r10d
  mov    %rax,0x60(%rsp)
  mov    $0x1,%eax
  cmovg  %r10d,%eax
  mov    %eax,%edi
  mov    %eax,0x4(%rsp)
  shr    %eax
  sub    $0x1,%eax
  and    $0xfffffffe,%edi
  mov    %rax,%r14
  add    $0x1,%rax
  mov    %edi,(%rsp)
  shl    $0x4,%rax
  shl    $0x4,%r14
  mov    %rax,0x70(%rsp)
  add    %rdx,%r14
  mov    $0x8,%eax
  test   %r10d,%r10d
  cmovg  0x10(%rsp),%rax
  mov    %rax,0x68(%rsp)
L406:
  mov    0x90(%rsp),%r12
  mov    0x80(%rsp),%r15
  xor    %ebp,%ebp
  movsd  %xmm2,0x8(%rsp)
L194:
  mov    0x10(%rsp),%rdx
  xor    %esi,%esi
  mov    %r13,%rdi
  mov    %rcx,0x48(%rsp)
  mov    %r8,0x40(%rsp)
  mov    %r9d,0x78(%rsp)
  mov    %r10d,0x3c(%rsp)
  movaps %xmm8,0x20(%rsp)
  movsd  %xmm7,0x30(%rsp)
  call   <memset@plt>
  lea    0x0(,%rbp,8),%rax
  mov    %r12,0x50(%rsp)
  mov    0x3c(%rsp),%r10d
  mov    %rax,0x18(%rsp)
  mov    0x58(%rsp),%rax
  xor    %esi,%esi
  pxor   %xmm2,%xmm2
  mov    0x60(%rsp),%r12
  mov    0x78(%rsp),%r9d
  mov    (%rax,%rbp,8),%rdi
  mov    D63(%rip),%rax
  mov    0x40(%rsp),%r8
  mov    0x48(%rsp),%rcx
  movsd  0x30(%rsp),%xmm7
  movapd 0x20(%rsp),%xmm8
  movq   %rax,%xmm3
  movq   D87(%rip),%xmm4
  movapd D106(%rip),%xmm9
  jmp    L294
L676:
  add    $0x1,%rsi
  cmp    %rbx,%rsi
  je     L397
  xchg   %ax,%ax
L294:
  movsd  (%rdi,%rsi,8),%xmm0
  ucomisd %xmm2,%xmm0
  jp     L687
  je     L676
L687:
  mov    (%r8,%rsi,8),%r11
  cmp    $0x1,%r10d
  je     L597
  movapd %xmm0,%xmm5
  mov    %r11,%rdx
  mov    %r13,%rax
  unpcklpd %xmm5,%xmm5
  nopl   0x0(%rax)
L119:
  movupd (%rdx),%xmm1
  add    $0x10,%rax
  add    $0x10,%rdx
  mulpd  %xmm5,%xmm1
  addpd  -0x10(%rax),%xmm1
  movaps %xmm1,-0x10(%rax)
  cmp    %r12,%rax
  jne    L119
  movslq 0x38(%rsp),%rax
  cmp    %r10d,%eax
  je     L676
L69:
  mulsd  (%r11,%rax,8),%xmm0
  add    $0x1,%rsi
  addsd  0xcd1f0(%rsp,%rax,8),%xmm0
  movsd  %xmm0,0xcd1f0(%rsp,%rax,8)
  cmp    %rbx,%rsi
  jne    L294
L397:
  mov    0x50(%rsp),%r12
  movsd  D52(%rip),%xmm6
  cs nopw 0x0(%rax,%rax,1)
L240:
  xor    %eax,%eax
  movapd %xmm2,%xmm5
  cs nopw 0x0(%rax,%rax,1)
L550:
  cmp    %eax,%ebp
  je     L361
  mov    (%r12),%rdx
  movsd  (%rdx,%rax,8),%xmm1
  comisd %xmm1,%xmm3
  jbe    L361
  movsd  (%rcx,%rax,8),%xmm12
  movsd  (%rdi,%rax,8),%xmm11
  mov    (%r15),%rdx
  movapd %xmm12,%xmm10
  mulsd  %xmm11,%xmm10
  movsd  (%rdx,%rax,8),%xmm0
  subsd  0x0(%r13,%rax,8),%xmm0
  addsd  %xmm10,%xmm0
  movapd %xmm0,%xmm10
  andpd  %xmm4,%xmm10
  subsd  %xmm1,%xmm10
  movapd %xmm2,%xmm1
  comisd %xmm10,%xmm2
  jae    L180
  comisd %xmm2,%xmm0
  movapd %xmm10,%xmm1
  jae    L476
  xorpd  %xmm8,%xmm1
L476:
  divsd  %xmm12,%xmm1
L180:
  movapd %xmm1,%xmm0
  subsd  %xmm11,%xmm0
  ucomisd %xmm2,%xmm0
  jp     L831
  je     L361
L831:
  movapd %xmm0,%xmm11
  andpd  %xmm4,%xmm11
  test   %r9d,%r9d
  je     L227
  comisd %xmm6,%xmm11
  ja     L227
  nopl   0x0(%rax,%rax,1)
L361:
  add    $0x1,%rax
  cmp    %rbx,%rax
  jne    L550
  comisd %xmm5,%xmm7
  jbe    L240
  movsd  (%rcx,%rbp,8),%xmm0
  mov    (%r8,%rbp,8),%rdi
  movsd  %xmm0,0x0(%r13,%rbp,8)
  cmp    $0x1,%r10d
  je     L754
  mov    0x70(%rsp),%rdx
  xor    %eax,%eax
  movapd %xmm2,%xmm1
  nopl   0x0(%rax)
L752:
  movapd 0x0(%r13,%rax,1),%xmm0
  movupd (%rdi,%rax,1),%xmm6
  add    $0x10,%rax
  subpd  %xmm6,%xmm0
  andpd  %xmm9,%xmm0
  addsd  %xmm0,%xmm1
  unpckhpd %xmm0,%xmm0
  addsd  %xmm0,%xmm1
  cmp    %rdx,%rax
  jne    L752
  movslq (%rsp),%rax
  mov    0x4(%rsp),%esi
  cmp    %esi,%eax
  je     L272
L404:
  movsd  0xcd1f0(%rsp,%rax,8),%xmm0
  subsd  (%rdi,%rax,8),%xmm0
  andpd  %xmm4,%xmm0
  addsd  %xmm0,%xmm1
L272:
  maxsd  0x8(%rsp),%xmm1
  mov    0x68(%rsp),%rdx
  mov    %r13,%rsi
  mov    %rcx,0x48(%rsp)
  mov    %r8,0x40(%rsp)
  mov    %r9d,0x78(%rsp)
  mov    %r10d,0x3c(%rsp)
  movaps %xmm8,0x20(%rsp)
  movsd  %xmm7,0x30(%rsp)
  movsd  %xmm1,0x8(%rsp)
  call   <memcpy@plt>
  mov    0x18(%rsp),%rsi
  mov    0x3c(%rsp),%r10d
  xor    %eax,%eax
  mov    0x78(%rsp),%r9d
  mov    0x40(%rsp),%r8
  pxor   %xmm2,%xmm2
  mov    0x48(%rsp),%rcx
  movapd 0x20(%rsp),%xmm8
  movsd  0x30(%rsp),%xmm7
  nopl   0x0(%rax)
L370:
  mov    (%r8,%rax,8),%rdx
  movsd  0x0(%r13,%rax,8),%xmm0
  add    $0x1,%rax
  movsd  %xmm0,(%rdx,%rsi,1)
  cmp    %eax,%r10d
  jg     L370
  add    $0x1,%rbp
  add    $0x8,%r12
  add    $0x8,%r15
  cmp    %rbx,%rbp
  jne    L194
  movsd  0xa8(%rsp),%xmm6
  comisd 0x8(%rsp),%xmm6
  jae    L175
  addl   $0x1,0x7c(%rsp)
  mov    0x7c(%rsp),%eax
  cmp    %eax,0x9c(%rsp)
  jge    L406
L175:
  mov    0xa0(%rsp),%rdi
  mov    0x88(%rsp),%r9
  xor    %esi,%esi
  movsd  D15(%rip),%xmm4
  mov    0x38(%rsp),%r11d
  shl    $0x4,%rdi
  add    $0x10,%r9
L788:
  mov    0x58(%rsp),%rax
  mov    (%r8,%rsi,1),%rbx
  mov    (%rax,%rsi,1),%rdx
  cmp    $0x1,%r10d
  je     L710
  xor    %eax,%eax
  movapd %xmm2,%xmm0
L787:
  movupd (%rbx,%rax,1),%xmm3
  movupd (%rdx,%rax,1),%xmm7
  add    $0x10,%rax
  mulpd  %xmm7,%xmm3
  addsd  %xmm3,%xmm0
  unpckhpd %xmm3,%xmm3
  addsd  %xmm3,%xmm0
  cmp    %rax,%rdi
  jne    L787
  movslq %r11d,%rax
  cmp    %r10d,%r11d
  je     L15
L67:
  movsd  (%rbx,%rax,8),%xmm1
  mulsd  (%rdx,%rax,8),%xmm1
  movapd %xmm4,%xmm3
  addsd  %xmm1,%xmm0
  movsd  (%rcx,%rsi,1),%xmm1
  subsd  %xmm0,%xmm1
  divsd  %xmm1,%xmm3
  movapd %xmm3,%xmm0
  xorpd  %xmm8,%xmm0
  cmp    $0x1,%r10d
  je     L217
L92:
  movapd %xmm0,%xmm5
  mov    %rdx,%rax
  lea    (%r9,%rdx,1),%rbx
  unpcklpd %xmm5,%xmm5
L878:
  movupd (%rax),%xmm1
  add    $0x10,%rax
  mulpd  %xmm5,%xmm1
  movups %xmm1,-0x10(%rax)
  cmp    %rax,%rbx
  jne    L878
  movslq %r11d,%rax
  cmp    %r10d,%r11d
  je     L543
L618:
  lea    (%rdx,%rax,8),%rax
  mulsd  (%rax),%xmm0
  movsd  %xmm0,(%rax)
L543:
  movsd  %xmm3,(%rdx,%rsi,1)
  add    $0x8,%rsi
  cmp    0x10(%rsp),%rsi
  jne    L788
  mov    0x98(%rsp),%eax
  test   %eax,%eax
  je     L850
  lea    -0x2(%r10),%r8d
  mov    0x58(%rsp),%r9
  xor    %esi,%esi
  mov    $0x1,%edi
  movsd  D42(%rip),%xmm1
  add    $0x2,%r8
L651:
  cmp    %edi,%r10d
  jle    L211
  mov    (%r9,%rsi,1),%rcx
  mov    %rdi,%rax
  nopl   0x0(%rax)
L868:
  mov    (%r9,%rax,8),%rdx
  movsd  (%rcx,%rax,8),%xmm0
  add    %rsi,%rdx
  addsd  (%rdx),%xmm0
  mulsd  %xmm1,%xmm0
  movsd  %xmm0,(%rcx,%rax,8)
  add    $0x1,%rax
  movsd  %xmm0,(%rdx)
  cmp    %eax,%r10d
  jg     L868
L211:
  add    $0x1,%rdi
  add    $0x8,%rsi
  cmp    %rdi,%r8
  jne    L651
L850:
  mov    0x19a338(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L168
  mov    0x7c(%rsp),%eax
  add    $0x19a348,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L224:
  xor    %eax,%eax
  jmp    L870
L439:
  lea    0x1(%r11),%rax
  mov    0x38(%rsp),%edx
  xor    %r9d,%r9d
  pxor   %xmm1,%xmm1
  mov    %rax,0xa0(%rsp)
  shl    $0x4,%rax
  mov    %rax,%rbp
  shl    $0x3,%rdx
L381:
  mov    0x80(%rsp),%rax
  mov    (%r8,%r9,8),%rcx
  mov    (%rax,%r9,8),%rdi
  mov    0x58(%rsp),%rax
  mov    (%rax,%r9,8),%rsi
  lea    0x8(%rdi),%r11
  cmp    %r11,%rsi
  setne  %al
  cmp    %r11,%rcx
  setne  %r11b
  and    %r11d,%eax
  cmpl   $0x2,0x98(%rsp)
  seta   %r11b
  test   %r11b,%al
  je     L874
  lea    0x8(%rcx),%r11
  xor    %eax,%eax
  cmp    %r11,%rsi
  je     L874
L379:
  movupd (%rdi,%rax,1),%xmm6
  movups %xmm6,(%rcx,%rax,1)
  movups %xmm1,(%rsi,%rax,1)
  add    $0x10,%rax
  cmp    %rbp,%rax
  jne    L379
  cmp    %r10d,0x38(%rsp)
  je     L824
  movsd  (%rdi,%rdx,1),%xmm0
  movsd  %xmm0,(%rcx,%rdx,1)
  movq   $0x0,(%rsi,%rdx,1)
L824:
  add    $0x1,%r9
  cmp    %rbx,%r9
  jne    L381
  movq   D137(%rip),%xmm8
  jmp    L14
  nopl   0x0(%rax)
L227:
  mov    (%r8,%rax,8),%r11
  movsd  %xmm1,(%rdi,%rax,8)
  cmp    $0x1,%r10d
  je     L614
  movapd %xmm0,%xmm10
  mov    %r11,%rsi
  mov    %r13,%rdx
  unpcklpd %xmm10,%xmm10
  nopw   0x0(%rax,%rax,1)
L105:
  movupd (%rsi),%xmm1
  add    $0x10,%rdx
  add    $0x10,%rsi
  mulpd  %xmm10,%xmm1
  addpd  -0x10(%rdx),%xmm1
  movaps %xmm1,-0x10(%rdx)
  cmp    %rdx,%r14
  jne    L105
  mov    (%rsp),%esi
  mov    0x4(%rsp),%edx
  cmp    %edx,%esi
  je     L583
  movslq %esi,%rdx
L507:
  mulsd  (%r11,%rdx,8),%xmm0
  addsd  0xcd1f0(%rsp,%rdx,8),%xmm0
  movsd  %xmm0,0xcd1f0(%rsp,%rdx,8)
L583:
  maxsd  %xmm5,%xmm11
  movapd %xmm11,%xmm5
  jmp    L361
L614:
  xor    %edx,%edx
  jmp    L507
L597:
  xor    %eax,%eax
  jmp    L69
L754:
  movapd %xmm2,%xmm1
  xor    %eax,%eax
  jmp    L404
L217:
  xor    %eax,%eax
  jmp    L618
L15:
  movsd  (%rcx,%rsi,1),%xmm1
  movapd %xmm4,%xmm3
  subsd  %xmm0,%xmm1
  divsd  %xmm1,%xmm3
  movapd %xmm3,%xmm0
  xorpd  %xmm8,%xmm0
  jmp    L92
L710:
  movapd %xmm2,%xmm0
  xor    %eax,%eax
  jmp    L67
L874:
  xor    %eax,%eax
L70:
  movsd  (%rdi,%rax,8),%xmm0
  movsd  %xmm0,(%rcx,%rax,8)
  movq   $0x0,(%rsi,%rax,8)
  add    $0x1,%rax
  cmp    %rbx,%rax
  jne    L70
  jmp    L824
L724:
  mov    0x10(%rsp),%rdi
  lea    (%rax,%rdi,1),%rdx
L42:
  movsd  (%rax),%xmm0
  add    $0x8,%rax
  xorpd  %xmm8,%xmm0
  divsd  (%rsi),%xmm0
  movsd  %xmm0,-0x8(%rax)
  cmp    %rdx,%rax
  jne    L42
  jmp    L522
L557:
  mov    0x10(%rsp),%r14
  xor    %r12d,%r12d
  mov    %r8,%r15
L643:
  mov    0x58(%rsp),%rax
  mov    (%r15,%r12,8),%r13
  mov    (%rax,%r12,8),%rdi
  lea    0x0(%r13,%r14,1),%rax
  cmp    %rax,%rdi
  jae    L667
  lea    (%rdi,%r14,1),%rax
  cmp    %rax,%r13
  jb     L242
L667:
  mov    %r14,%rdx
  xor    %esi,%esi
  call   <memset@plt>
  mov    %r14,%rdx
  xor    %esi,%esi
  mov    %r13,%rdi
  call   <memset@plt>
L314:
  add    $0x1,%r12
  cmp    %rbx,%r12
  jne    L643
  mov    0x90(%rsp),%rsi
  mov    %r15,%r8
  xor    %eax,%eax
L427:
  mov    (%r8,%rax,1),%rdx
  mov    (%rsi,%rax,1),%rcx
  add    %rax,%rdx
  movsd  (%rdx),%xmm0
  addsd  (%rcx,%rax,1),%xmm0
  add    $0x8,%rax
  movsd  %xmm0,(%rdx)
  cmp    0x10(%rsp),%rax
  jne    L427
  mov    0x58(%rsp),%rax
  mov    %r8,%r12
  mov    %rax,%rbx
  lea    0x8(%rax,%rbp,1),%rbp
L126:
  mov    (%rbx),%rdi
  mov    0x10(%rsp),%rdx
  xor    %esi,%esi
  add    $0x8,%rbx
  call   <memset@plt>
  cmp    %rbp,%rbx
  jne    L126
  movsd  D117(%rip),%xmm2
  movsd  D15(%rip),%xmm1
  mov    %r12,%r8
  xor    %eax,%eax
  mov    0x58(%rsp),%rdx
L800:
  mov    (%r8,%rax,1),%rcx
  movsd  (%rcx,%rax,1),%xmm0
  comisd D92(%rip),%xmm0
  mov    (%rdx,%rax,1),%rcx
  jbe    L29
  movapd %xmm1,%xmm3
  divsd  %xmm0,%xmm3
  movsd  %xmm3,(%rcx,%rax,1)
  add    $0x8,%rax
  cmp    0x10(%rsp),%rax
  jne    L800
L620:
  movl   $0x0,0x7c(%rsp)
  jmp    L850
L29:
  movsd  %xmm2,(%rcx,%rax,1)
  add    $0x8,%rax
  cmp    0x10(%rsp),%rax
  jne    L800
  movl   $0x0,0x7c(%rsp)
  jmp    L850
L242:
  xor    %eax,%eax
L10:
  movq   $0x0,(%rdi,%rax,8)
  movq   $0x0,0x0(%r13,%rax,8)
  add    $0x1,%rax
  cmp    %rbx,%rax
  jne    L10
  jmp    L314
L191:
  movl   $0x1,0x7c(%rsp)
  jmp    L175
L168:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: label: D87
type_infered: qword
name: unpack_data
arguments: label: D106
type_infered: qword[2]
name: unpack_data
arguments: label: D90
type_infered: byte[8]
name: unpack_data
arguments: label: D17
type_infered: f32[4]
name: unpack_data
arguments: label: D137
type_infered: f32[2]
name: unpack_data
arguments: label: D63
type_infered: f64
name: unpack_data
arguments: label: D52
type_infered: byte[8]
name: unpack_data
arguments: label: D15
type_infered: f64
name: unpack_data
arguments: label: D42
type_infered: f64
name: unpack_data
arguments: label: D117
type_infered: byte[8]
name: unpack_data
arguments: label: D92
type_infered: byte[16]

tool: D87: 9223372036854775807

tool: {"D106": [0x7fffffffffffffff,0x7fffffffffffffff]}

tool: {"D90": [0xb1,0xde,0x64,0xc8,0xda,0xd0,0xe3,0x3c]}

tool: {"D17": [0.0,-0.0,0.0,-0.0]}

tool: {"D137": [0.0,-0.0]}

tool: D63: 1000000000

tool: {"D52": [0x8d,0xed,0xb5,0xa0,0xf7,0xc6,0xb0,0x3e]}

tool: D15: 1

tool: D42: 0.5

tool: {"D117": [0xe9,0xa2,0xa3,0xc5,0x81,0xd6,0x09,0x43]}

tool: {"D92": [0xb1,0xde,0x64,0xc8,0xda,0xd0,0xd3,0x3c,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

assistant: ```c
int glassofast(const int n, double **S, double **L, const double thr, const int maxit, int approxflg, int warm, double **X, double **W) {
  int i, j, ii, iter, jj;
  double a, b, c, delta, dlx, dw, shr, sum, thrlasso, tmp, wd[5000 * 21], wxj[5000 * 21];
  for (shr = ii = 0; ii < n; ii++)
    for (jj = 0; jj < n; jj++)
      shr += fabs(S[ii][jj]);
  for (i = 0; i < n; i++)
    shr -= fabs(S[i][i]);
  if (shr == 0.0) {
    for (ii = 0; ii < n; ii++)
      for (jj = 0; jj < n; jj++)
        W[ii][jj] = X[ii][jj] = 0.0;
    for (i = 0; i < n; i++)
      W[i][i] = W[i][i] + L[i][i];
    for (ii = 0; ii < n; ii++)
      for (jj = 0; jj < n; jj++)
        X[ii][jj] = 0.0;
    for (i = 0; i < n; i++)
      X[i][i] = 1.0 / ((W[i][i]) > ((1.1e-15)) ? (W[i][i]) : ((1.1e-15)));
    return 0;
  }
  shr *= thr / (n - 1);
  thrlasso = shr / n;
  if (thrlasso < 2 * (1.1e-15))
    thrlasso = 2 * (1.1e-15);
  if (!warm) {
    for (ii = 0; ii < n; ii++)
      for (jj = 0; jj < n; jj++) {
        W[ii][jj] = S[ii][jj];
        X[ii][jj] = 0.0;
      }
  } else {
    for (i = 0; i < n; i++) {
      for (ii = 0; ii < n; ii++)
        X[i][ii] = -X[i][ii] / X[i][i];
      X[i][i] = 0.0;
    }
  }
  for (i = 0; i < n; i++) {
    wd[i] = S[i][i] + L[i][i];
    W[i][i] = wd[i];
  }
  for (iter = 1; iter <= maxit; iter++) {
    dw = 0.0;
#pragma omp parallel for default(shared) private(i, j, ii, wxj, a, b, c, dlx, delta, sum)
    for (j = 0; j < n; j++) {
      for (ii = 0; ii < n; ii++)
        wxj[ii] = 0.0;
      for (i = 0; i < n; i++)
        if (X[j][i] != 0.0)
          for (ii = 0; ii < n; ii++)
            wxj[ii] += W[i][ii] * X[j][i];
      for (;;) {
        dlx = 0.0;
        for (i = 0; i < n; i++) {
          if (i != j && L[j][i] < (1e9)) {
            a = S[j][i] - wxj[i] + wd[i] * X[j][i];
            b = fabs(a) - L[j][i];
            if (b <= 0.0)
              c = 0.0;
            else if (a >= 0.0)
              c = b / wd[i];
            else
              c = -b / wd[i];
            delta = c - X[j][i];
            if (delta != 0.0 && (!approxflg || fabs(delta) > 1e-6)) {
              X[j][i] = c;
              for (ii = 0; ii < n; ii++)
                wxj[ii] += W[i][ii] * delta;
              if (fabs(delta) > dlx)
                dlx = fabs(delta);
            }
          }
        }
        if (dlx < thrlasso)
          break;
      }
      wxj[j] = wd[j];
      for (sum = ii = 0; ii < n; ii++)
        sum += fabs(wxj[ii] - W[j][ii]);
#pragma omp critical
      if (sum > dw)
        dw = sum;
      for (ii = 0; ii < n; ii++)
        W[j][ii] = wxj[ii];
      for (ii = 0; ii < n; ii++)
        W[ii][j] = wxj[ii];
    }
    if (dw <= shr)
      break;
  }
  for (i = 0; i < n; i++) {
    for (sum = ii = 0; ii < n; ii++)
      sum += X[i][ii] * W[i][ii];
    tmp = 1.0 / (wd[i] - sum);
    for (ii = 0; ii < n; ii++)
      X[i][ii] = -tmp * X[i][ii];
    X[i][i] = tmp;
  }
  for (i = 0; i < n - 1; i++) {
    for (ii = i + 1; ii < n; ii++) {
      X[i][ii] = 0.5 * (X[i][ii] + X[ii][i]);
      X[ii][i] = X[i][ii];
    }
  }
  return iter;
}
```