user: Demonstrate the C code that generates the assembly output below:

```asm
<set_timestep_interval>:
  endbr64
  comisd D2(%rip),%xmm3
  jb     L15
  push   %rbx
  mov    %esi,%ebx
  mov    %esi,%r9d
  movapd %xmm0,%xmm7
  add    $0x1,%ebx
  js     L59
  mov    %ebx,%eax
  mov    %edx,%esi
  movq   D60(%rip),%xmm4
  lea    0x8(%rcx,%rax,8),%r10
  mov    %edx,%eax
  mov    D2(%rip),%rdx
  lea    0x10(,%rax,8),%r11
  movq   %rdx,%xmm5
  nopl   0x0(%rax)
L117:
  test   %esi,%esi
  js     L28
  mov    (%rcx),%rdx
  lea    0x8(%rdx),%rax
  add    %r11,%rdx
  xchg   %ax,%ax
L113:
  movsd  (%rax),%xmm0
  add    $0x8,%rax
  andpd  %xmm4,%xmm0
  maxsd  %xmm5,%xmm0
  movapd %xmm0,%xmm5
  cmp    %rdx,%rax
  jne    L113
L28:
  add    $0x8,%rcx
  cmp    %r10,%rcx
  jne    L117
  test   %ebx,%ebx
  jle    L40
  mov    D2(%rip),%rbx
  mov    %r9d,%r9d
  lea    0x1(%rsi),%eax
  movq   D60(%rip),%xmm6
  lea    0x8(%r8),%rcx
  lea    0x10(%r8,%r9,8),%r8
  movq   %rbx,%xmm4
  lea    0x8(,%rax,8),%r9
  nopl   (%rax)
L2:
  cmp    $0xffffffff,%esi
  jl     L112
  mov    (%rcx),%rax
  lea    (%r9,%rax,1),%rdx
  nopl   0x0(%rax)
L79:
  movsd  (%rax),%xmm0
  add    $0x8,%rax
  andpd  %xmm6,%xmm0
  maxsd  %xmm4,%xmm0
  movapd %xmm0,%xmm4
  cmp    %rdx,%rax
  jne    L79
L112:
  add    $0x8,%rcx
  cmp    %r8,%rcx
  jne    L2
L34:
  movapd %xmm7,%xmm6
  movsd  D13(%rip),%xmm0
  mulsd  %xmm7,%xmm7
  divsd  %xmm5,%xmm6
  movapd %xmm1,%xmm5
  mulsd  %xmm1,%xmm1
  divsd  %xmm4,%xmm5
  movapd %xmm0,%xmm4
  divsd  %xmm7,%xmm4
  movapd %xmm0,%xmm7
  comisd %xmm6,%xmm5
  divsd  %xmm1,%xmm7
  movapd %xmm4,%xmm1
  addsd  %xmm7,%xmm1
  divsd  %xmm1,%xmm0
  mulsd  %xmm2,%xmm0
  mulsd  D75(%rip),%xmm0
  ja     L39
  movapd %xmm5,%xmm6
L39:
  minsd  %xmm0,%xmm6
  pop    %rbx
  mulsd  %xmm6,%xmm3
  movsd  %xmm3,(%rdi)
  ret
  nopw   0x0(%rax,%rax,1)
L15:
  ret
L59:
  mov    D2(%rip),%rax
  movq   %rax,%xmm5
  movq   %rax,%xmm4
  jmp    L34
L40:
  mov    D2(%rip),%rax
  movq   %rax,%xmm4
  jmp    L34
```

tool_calls: name: parse_data
arguments: data_label: D2
type_infered: byte[16]
name: parse_data
arguments: data_label: D60
type_infered: qword
name: parse_data
arguments: data_label: D13
type_infered: byte[8]
name: parse_data
arguments: data_label: D75
type_infered: byte[8]

tool: {"D2": [0xbb,0xbd,0xd7,0xd9,0xdf,0x7c,0xdb,0x3d,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

tool: D60: 9223372036854775807

tool: {"D13": [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

tool: {"D75": [0x00,0x00,0x00,0x00,0x00,0x00,0xe0,0x3f]}

assistant: ```c
void set_timestep_interval(double *del_t, int imax, int jmax, double delx, double dely, double **u, double **v, double Re, double tau) {
  int i, j;
  double umax, vmax, deltu, deltv, deltRe;
  if (tau >= 1.0e-10) {
    umax = 1.0e-10;
    vmax = 1.0e-10;
    for (i = 0; i <= imax + 1; i++) {
      for (j = 1; j <= jmax + 1; j++) {
        umax = ((fabs(u[i][j])) > (umax) ? (fabs(u[i][j])) : (umax));
      }
    }
    for (i = 1; i <= imax + 1; i++) {
      for (j = 0; j <= jmax + 1; j++) {
        vmax = ((fabs(v[i][j])) > (vmax) ? (fabs(v[i][j])) : (vmax));
      }
    }
    deltu = delx / umax;
    deltv = dely / vmax;
    deltRe = 1 / (1 / (delx * delx) + 1 / (dely * dely)) * Re / 2.0;
    if (deltu < deltv) {
      *del_t = ((deltu) < (deltRe) ? (deltu) : (deltRe));
    } else {
      *del_t = ((deltv) < (deltRe) ? (deltv) : (deltRe));
    }
    *del_t = tau * (*del_t);
  }
}
```