user: 请将这段汇编代码片段转换成等效的C代码:

```asm
<orthes>:
  endbr64
  push   %r15
  push   %r14
  mov    %rdx,%r14
  push   %r13
  push   %r12
  mov    %rsi,%r12
  push   %rbp
  lea    -0x1(%rdi),%ebp
  push   %rbx
  mov    %rcx,%rbx
  sub    $0x58,%rsp
  cmp    $0x1,%ebp
  jle    L136
  lea    -0x3(%rdi),%eax
  mov    %r14,0x8(%rsp)
  movq   D11(%rip),%xmm4
  mov    $0x1,%edx
  lea    0x2(%rax),%r9
  movq   D15(%rip),%xmm5
  mov    %ebp,%eax
  pxor   %xmm2,%xmm2
  lea    0x8(%rsi,%rax,8),%r10
  nopl   0x0(%rax,%rax,1)
L237:
  lea    0x0(,%rdx,8),%r13
  mov    %edx,%eax
  movapd %xmm2,%xmm3
  mov    %rdx,%rcx
  lea    -0x8(%r13),%r15
  nopl   (%rax)
L138:
  mov    (%r12,%rcx,8),%rsi
  add    $0x1,%rcx
  movsd  (%rsi,%r15,1),%xmm0
  andpd  %xmm4,%xmm0
  addsd  %xmm0,%xmm3
  cmp    %ecx,%ebp
  jge    L138
  ucomisd %xmm2,%xmm3
  jp     L348
  lea    0x1(%rdx),%r8
  jne    L348
L304:
  mov    %r8,%rdx
  cmp    %r8,%r9
  jne    L237
  mov    0x8(%rsp),%r14
L136:
  test   %edi,%edi
  jle    L61
  movsd  D38(%rip),%xmm2
  movslq %edi,%rcx
  xor    %edx,%edx
  pxor   %xmm1,%xmm1
L201:
  mov    (%r14,%rdx,8),%rsi
  xor    %eax,%eax
  jmp    L0
  nopl   0x0(%rax,%rax,1)
L19:
  movsd  %xmm0,(%rsi,%rax,8)
  add    $0x1,%rax
  cmp    %rax,%rcx
  je     L119
L0:
  movapd %xmm1,%xmm0
  cmp    %eax,%edx
  jne    L19
  movapd %xmm2,%xmm0
  movsd  %xmm0,(%rsi,%rax,8)
  add    $0x1,%rax
  cmp    %rax,%rcx
  jne    L0
L119:
  add    $0x1,%rdx
  cmp    %rdx,%rcx
  jne    L201
L61:
  lea    -0x2(%rdi),%esi
  test   %esi,%esi
  jle    L105
  movslq %esi,%rsi
  mov    %ebp,%r13d
  pxor   %xmm2,%xmm2
  lea    0x0(,%rsi,8),%r8
  jmp    L101
L262:
  sub    $0x1,%rsi
  sub    $0x1,%r13d
  test   %esi,%esi
  jle    L105
L101:
  mov    (%r12,%r8,1),%rcx
  mov    %r8,%r9
  sub    $0x8,%r8
  add    %r8,%rcx
  ucomisd (%rcx),%xmm2
  jp     L263
  je     L262
L263:
  movslq %r13d,%rax
  cmp    %r13d,%ebp
  jl     L123
  xchg   %ax,%ax
L368:
  mov    (%r12,%rax,8),%rdx
  movsd  (%rdx,%r8,1),%xmm0
  movsd  %xmm0,(%rbx,%rax,8)
  add    $0x1,%rax
  cmp    %eax,%ebp
  jge    L368
L123:
  cmp    %esi,%ebp
  jl     L262
  mov    %edi,%eax
  mov    %r9,%rdx
  sub    %r13d,%eax
  lea    0x1(%rsi,%rax,1),%r10
  shl    $0x3,%r10
  nopl   0x0(%rax)
L159:
  mov    %rsi,%rax
  movapd %xmm2,%xmm1
  nopw   0x0(%rax,%rax,1)
L208:
  mov    (%r14,%rax,8),%r11
  movsd  (%r11,%rdx,1),%xmm0
  mulsd  (%rbx,%rax,8),%xmm0
  add    $0x1,%rax
  addsd  %xmm0,%xmm1
  cmp    %eax,%ebp
  jge    L208
  movsd  (%rbx,%r9,1),%xmm0
  mov    %rsi,%rax
  divsd  %xmm0,%xmm1
  divsd  (%rcx),%xmm1
  jmp    L160
  xchg   %ax,%ax
L357:
  movsd  (%rbx,%rax,8),%xmm0
L160:
  mov    (%r14,%rax,8),%r11
  mulsd  %xmm1,%xmm0
  add    $0x1,%rax
  add    %rdx,%r11
  addsd  (%r11),%xmm0
  movsd  %xmm0,(%r11)
  cmp    %eax,%ebp
  jge    L357
  add    $0x8,%rdx
  cmp    %rdx,%r10
  jne    L159
  sub    $0x1,%rsi
  sub    $0x1,%r13d
  test   %esi,%esi
  jg     L101
L105:
  add    $0x58,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopw   0x0(%rax,%rax,1)
L348:
  movslq %ebp,%rcx
  movapd %xmm2,%xmm7
  mov    %edx,%r14d
  mov    %rcx,%rsi
  nopl   (%rax)
L100:
  mov    (%r12,%rsi,8),%r8
  movsd  (%r8,%r15,1),%xmm0
  divsd  %xmm3,%xmm0
  movsd  %xmm0,(%rbx,%rsi,8)
  mulsd  %xmm0,%xmm0
  sub    $0x1,%rsi
  addsd  %xmm0,%xmm7
  cmp    %esi,%edx
  jle    L100
  ucomisd %xmm7,%xmm2
  ja     L95
  movapd %xmm7,%xmm6
  sqrtsd %xmm6,%xmm6
L76:
  movsd  (%rbx,%rdx,8),%xmm0
  comisd %xmm2,%xmm0
  jbe    L236
  xorpd  %xmm5,%xmm6
L236:
  movapd %xmm0,%xmm1
  subsd  %xmm6,%xmm0
  lea    0x1(%rdx),%r8
  mulsd  %xmm6,%xmm1
  movsd  %xmm0,(%rbx,%rdx,8)
  subsd  %xmm1,%xmm7
  cmp    %r14d,%edi
  jle    L192
  mov    %ebp,%esi
  sub    %eax,%esi
  add    %r8,%rsi
  shl    $0x3,%rsi
  nopl   0x0(%rax)
L14:
  mov    %rcx,%rax
  movapd %xmm2,%xmm8
L258:
  mov    (%r12,%rax,8),%r11
  movsd  (%r11,%r13,1),%xmm1
  mulsd  (%rbx,%rax,8),%xmm1
  sub    $0x1,%rax
  addsd  %xmm1,%xmm8
  cmp    %eax,%r14d
  jle    L258
  divsd  %xmm7,%xmm8
  mov    %rdx,%rax
  jmp    L214
  nopw   0x0(%rax,%rax,1)
L81:
  movsd  (%rbx,%rax,8),%xmm0
L214:
  mov    (%r12,%rax,8),%r11
  mulsd  %xmm8,%xmm0
  add    $0x1,%rax
  add    %r13,%r11
  movsd  (%r11),%xmm1
  subsd  %xmm0,%xmm1
  movsd  %xmm1,(%r11)
  cmp    %eax,%ebp
  jge    L81
  add    $0x8,%r13
  movsd  (%rbx,%rdx,8),%xmm0
  cmp    %r13,%rsi
  jne    L14
L192:
  mov    %r12,%r11
  nopl   0x0(%rax,%rax,1)
L329:
  mov    (%r11),%rsi
  mov    %rcx,%rax
  movapd %xmm2,%xmm8
  nopl   0x0(%rax,%rax,1)
L54:
  movsd  (%rbx,%rax,8),%xmm1
  mulsd  (%rsi,%rax,8),%xmm1
  sub    $0x1,%rax
  addsd  %xmm1,%xmm8
  cmp    %eax,%r14d
  jle    L54
  divsd  %xmm7,%xmm8
  mov    %rdx,%rax
  jmp    L375
  nopw   0x0(%rax,%rax,1)
L73:
  movsd  (%rbx,%rax,8),%xmm0
L375:
  mulsd  %xmm8,%xmm0
  movsd  (%rsi,%rax,8),%xmm1
  subsd  %xmm0,%xmm1
  movsd  %xmm1,(%rsi,%rax,8)
  add    $0x1,%rax
  cmp    %eax,%ebp
  jge    L73
  add    $0x8,%r11
  movsd  (%rbx,%rdx,8),%xmm0
  cmp    %r11,%r10
  jne    L329
  mulsd  %xmm3,%xmm0
  mov    (%r12,%rdx,8),%rax
  mulsd  %xmm6,%xmm3
  movsd  %xmm0,(%rbx,%rdx,8)
  movsd  %xmm3,(%rax,%r15,1)
  jmp    L304
L95:
  movapd %xmm7,%xmm0
  mov    %edi,0x4c(%rsp)
  mov    %r10,0x40(%rsp)
  mov    %rdx,0x38(%rsp)
  mov    %r9,0x30(%rsp)
  mov    %rcx,0x20(%rsp)
  mov    %eax,0x48(%rsp)
  movsd  %xmm2,0x28(%rsp)
  movsd  %xmm3,0x18(%rsp)
  movsd  %xmm7,0x10(%rsp)
  call   <sqrt@plt>
  mov    0x4c(%rsp),%edi
  mov    0x40(%rsp),%r10
  mov    0x38(%rsp),%rdx
  mov    0x30(%rsp),%r9
  movapd %xmm0,%xmm6
  movq   D15(%rip),%xmm5
  movq   D11(%rip),%xmm4
  movsd  0x28(%rsp),%xmm2
  mov    0x20(%rsp),%rcx
  mov    0x48(%rsp),%eax
  movsd  0x18(%rsp),%xmm3
  movsd  0x10(%rsp),%xmm7
  jmp    L76
```

tool_calls: name: retrieve_data
arguments: tag: D11
datatype: qword
name: retrieve_data
arguments: tag: D15
datatype: f32[2]
name: retrieve_data
arguments: tag: D38
datatype: f64

tool: D11: 9223372036854775807

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

tool: D38: 1

assistant: ```c
void orthes(int n, double **H, double **V, double *ort) {
  int low = 0;
  int high = n - 1;
  for (int m = low + 1; m <= high - 1; m++) {
    double scale = 0.0;
    for (int i = m; i <= high; i++) {
      scale = scale + fabs(H[i][m - 1]);
    }
    if (scale != 0.0) {
      double h = 0.0;
      for (int i = high; i >= m; i--) {
        ort[i] = H[i][m - 1] / scale;
        h += ort[i] * ort[i];
      }
      double g = sqrt(h);
      if (ort[m] > 0) {
        g = -g;
      }
      h = h - ort[m] * g;
      ort[m] = ort[m] - g;
      for (int j = m; j < n; j++) {
        double f = 0.0;
        for (int i = high; i >= m; i--) {
          f += ort[i] * H[i][j];
        }
        f = f / h;
        for (int i = m; i <= high; i++) {
          H[i][j] -= f * ort[i];
        }
      }
      for (int i = 0; i <= high; i++) {
        double f = 0.0;
        for (int j = high; j >= m; j--) {
          f += ort[j] * H[i][j];
        }
        f = f / h;
        for (int j = m; j <= high; j++) {
          H[i][j] -= f * ort[j];
        }
      }
      ort[m] = scale * ort[m];
      H[m][m - 1] = scale * g;
    }
  }
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      V[i][j] = (i == j ? 1.0 : 0.0);
    }
  }
  for (int m = high - 1; m >= low + 1; m--) {
    if (H[m][m - 1] != 0.0) {
      for (int i = m + 1; i <= high; i++) {
        ort[i] = H[i][m - 1];
      }
      for (int j = m; j <= high; j++) {
        double g = 0.0;
        for (int i = m; i <= high; i++) {
          g += ort[i] * V[i][j];
        }
        g = (g / ort[m]) / H[m][m - 1];
        for (int i = m; i <= high; i++) {
          V[i][j] += g * ort[i];
        }
      }
    }
  }
}
```