user: Translate the below assembly code into C programming language:

```asm
<dist_2v_allt_v2>:
  endbr64
  push   %r15
  push   %r14
  mov    %rdi,%r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0xc8,%rsp
  mov    0x108(%rsp),%eax
  mov    0x130(%rsp),%ebx
  mov    %rdx,0x58(%rsp)
  mov    %rcx,0x78(%rsp)
  mov    0x150(%rsp),%ebp
  mov    %eax,0x68(%rsp)
  mov    0x110(%rsp),%rax
  mov    %r8,0x60(%rsp)
  mov    0x100(%rsp),%r12d
  mov    %rax,0x98(%rsp)
  mov    0x118(%rsp),%rax
  mov    %rsi,0x48(%rsp)
  mov    %rax,0x38(%rsp)
  mov    0x120(%rsp),%eax
  mov    %r9,0x80(%rsp)
  mov    %eax,0x88(%rsp)
  mov    0x128(%rsp),%eax
  mov    %ebx,0x24(%rsp)
  mov    %eax,0x8c(%rsp)
  mov    0x138(%rsp),%rax
  mov    %rax,0x90(%rsp)
  mov    0x140(%rsp),%eax
  mov    %eax,0x70(%rsp)
  mov    0x148(%rsp),%eax
  mov    %eax,0xa0(%rsp)
  mov    0x158(%rsp),%eax
  mov    0x4(%rsi),%r9d
  mov    0x4(%rdi),%r15d
  mov    $0x2710,%esi
  mov    $0x1,%edi
  mov    %eax,0xa4(%rsp)
  mov    0x160(%rsp),%eax
  mov    %r9d,0x1c(%rsp)
  mov    %eax,0xa8(%rsp)
  mov    0x168(%rsp),%eax
  mov    %eax,0x74(%rsp)
  call   <ivector@plt>
  mov    $0x2710,%esi
  mov    $0x1,%edi
  mov    %rax,0x10(%rsp)
  call   <cvector@plt>
  mov    $0x2710,%esi
  mov    $0x1,%edi
  mov    %rax,0x8(%rsp)
  call   <ivector@plt>
  mov    $0x2710,%esi
  mov    $0x1,%edi
  mov    %rax,0x30(%rsp)
  call   <cvector@plt>
  mov    $0x6,%ecx
  mov    $0x1,%edx
  mov    $0xc350,%esi
  mov    $0x1,%edi
  mov    %rax,0x28(%rsp)
  call   <imatrix@plt>
  test   %ebp,%ebp
  mov    0x1c(%rsp),%r9d
  mov    %rax,0x40(%rsp)
  lea    0x1(%rbx),%eax
  cmovns %ebp,%eax
  test   %ebx,%ebx
  mov    %eax,0x20(%rsp)
  jle    L137
  mov    0x20(%rsp),%eax
  test   %eax,%eax
  js     L137
  movl   $0x0,0x50(%rsp)
  mov    0x68(%rsp),%r10d
  xor    %ebx,%ebx
  mov    $0x1,%r13d
  movl   $0x0,0x1c(%rsp)
  mov    $0x1,%ebp
  mov    %r15d,%esi
  movl   $0x0,0x6c(%rsp)
  movl   $0x0,0x54(%rsp)
  nopw   0x0(%rax,%rax,1)
L292:
  mov    %esi,%eax
  or     %r9d,%eax
  jns    L105
  mov    0x24(%rsp),%eax
  xor    %r15d,%r15d
  lea    0x1(%rax),%ebx
L326:
  mov    %esi,%eax
  cmp    %ebp,%r12d
  not    %eax
  setg   %dl
  shr    $0x1f,%eax
  test   %al,%dl
  je     L174
  cmp    %esi,%ebx
  lea    0x1(%rbp),%eax
  setg   %dl
  cltq
  test   %dl,%dl
  je     L174
  nopl   0x0(%rax)
L430:
  mov    (%r14,%rax,4),%esi
  mov    %eax,%ebp
  mov    %esi,%ecx
  cmp    %ebx,%esi
  not    %ecx
  setl   %dl
  shr    $0x1f,%ecx
  and    %ecx,%edx
  cmp    %eax,%r12d
  setg   %cl
  add    $0x1,%rax
  test   %cl,%dl
  jne    L430
L174:
  cmp    %esi,%ebx
  je     L318
L258:
  mov    0x20(%rsp),%edi
  cmp    %edi,0x1c(%rsp)
  jg     L338
  test   %r15b,%r15b
  jne    L292
L338:
  mov    0x50(%rsp),%ebx
  movd   0x1c(%rsp),%xmm1
  mov    0x38(%rsp),%rax
  mov    0x54(%rsp),%edi
  movd   %ebx,%xmm0
  punpckldq %xmm1,%xmm0
  mov    %edi,0x8(%rax)
  movq   %xmm0,(%rax)
  test   %edi,%edi
  js     L180
L242:
  mov    0x50(%rsp),%edi
  mov    0x38(%rsp),%rax
  mov    $0x2710,%edx
  mov    $0x1,%esi
  mov    %edi,0xc(%rax)
  mov    0x10(%rsp),%rdi
  call   <free_ivector@plt>
  mov    0x8(%rsp),%rdi
  mov    $0x2710,%edx
  mov    $0x1,%esi
  call   <free_cvector@plt>
  mov    0x30(%rsp),%rdi
  mov    $0x2710,%edx
  mov    $0x1,%esi
  call   <free_ivector@plt>
  mov    0x28(%rsp),%rdi
  mov    $0x2710,%edx
  mov    $0x1,%esi
  call   <free_cvector@plt>
  mov    0x40(%rsp),%rdi
  mov    $0x6,%r8d
  add    $0xc8,%rsp
  pop    %rbx
  mov    $0x1,%ecx
  pop    %rbp
  mov    $0xc350,%edx
  pop    %r12
  mov    $0x1,%esi
  pop    %r13
  pop    %r14
  pop    %r15
  jmp    1150 <free_imatrix@plt>
  nopw   0x0(%rax,%rax,1)
L105:
  add    $0x1,%ebx
  cmp    %ebx,0x24(%rsp)
  setg   %r15b
  jmp    L326
L318:
  cmp    %ebp,%r12d
  jl     L90
  mov    0x58(%rsp),%rax
  movslq %ebp,%rcx
  mov    0x60(%rsp),%rdi
  mov    %ebp,%edx
  lea    0x0(,%rcx,4),%rsi
  lea    (%rax,%rsi,1),%r11
  add    %rcx,%rdi
  add    %r14,%rsi
  mov    $0x1,%eax
  nop
L355:
  mov    -0x4(%r11,%rax,4),%ecx
  mov    0x10(%rsp),%rbp
  mov    %eax,%r8d
  mov    %ecx,0x0(%rbp,%rax,4)
  mov    0x8(%rsp),%rbp
  movzbl -0x1(%rdi,%rax,1),%ecx
  mov    %cl,0x0(%rbp,%rax,1)
  mov    %edx,%ebp
  add    $0x1,%edx
  cmp    %edx,%r12d
  jge    L6
L380:
  mov    %r9d,%eax
  not    %eax
  shr    $0x1f,%eax
  cmp    %r13d,%r10d
  setg   %dl
  test   %al,%dl
  je     L444
  cmp    %r9d,%ebx
  jle    L444
  lea    0x1(%r13),%eax
  mov    0x48(%rsp),%rsi
  cltq
  nop
L120:
  mov    (%rsi,%rax,4),%r9d
  mov    %eax,%r13d
  mov    %r9d,%ecx
  cmp    %ebx,%r9d
  not    %ecx
  setl   %dl
  shr    $0x1f,%ecx
  and    %ecx,%edx
  cmp    %eax,%r10d
  setg   %cl
  add    $0x1,%rax
  test   %cl,%dl
  jne    L120
L444:
  mov    %ebx,%esi
  cmp    %r9d,%ebx
  jne    L258
  cmp    %r13d,%r10d
  jl     L229
  mov    0x78(%rsp),%rax
  movslq %r13d,%rcx
  mov    0x80(%rsp),%rdi
  mov    %r13d,%edx
  lea    0x0(,%rcx,4),%rsi
  lea    (%rax,%rsi,1),%r9
  add    %rcx,%rdi
  add    0x48(%rsp),%rsi
  mov    $0x1,%eax
  nopl   (%rax)
L4:
  mov    -0x4(%r9,%rax,4),%ecx
  mov    0x30(%rsp),%r13
  mov    %eax,%r11d
  mov    %ecx,0x0(%r13,%rax,4)
  mov    0x28(%rsp),%r13
  movzbl -0x1(%rdi,%rax,1),%ecx
  mov    %cl,0x0(%r13,%rax,1)
  mov    %edx,%r13d
  add    $0x1,%edx
  cmp    %edx,%r10d
  jge    L278
L217:
  mov    0x74(%rsp),%ecx
  test   %ecx,%ecx
  jne    L359
L156:
  cmpl   $0x1,0xa0(%rsp)
  mov    %r10d,0x68(%rsp)
  je     L267
  sub    $0x8,%rsp
  mov    %r11d,%r9d
  mov    0x78(%rsp),%eax
  push   %rax
  push   0xa0(%rsp)
  push   $0xc350
  mov    0xac(%rsp),%eax
  push   %rax
  mov    0xb0(%rsp),%eax
  push   %rax
  push   0x68(%rsp)
  push   0x78(%rsp)
  mov    0x68(%rsp),%rcx
  mov    0x48(%rsp),%rdx
  mov    0x70(%rsp),%rsi
  mov    0x50(%rsp),%rdi
  call   <dist_2v_unordered_v3@plt>
  mov    0xa8(%rsp),%r10d
  add    $0x40,%rsp
L38:
  mov    0x38(%rsp),%rdi
  mov    0x74(%rsp),%edx
  mov    0x54(%rsp),%eax
  add    0x4(%rdi),%eax
  mov    (%rdi),%r11d
  mov    %eax,0x68(%rsp)
  mov    %eax,0x54(%rsp)
  test   %edx,%edx
  jne    L327
  test   %r11d,%r11d
  jle    L260
L153:
  addl   $0x1,0x1c(%rsp)
L260:
  mov    0x50(%rsp),%eax
  cmpl   $0x1,0x70(%rsp)
  lea    (%r11,%rax,1),%ecx
  je     L429
L333:
  mov    %ecx,0x50(%rsp)
  mov    %ebx,%r9d
  mov    %ebx,%esi
  jmp    L258
  nopw   0x0(%rax,%rax,1)
L6:
  cmp    %ebx,(%rsi,%rax,4)
  sete   %cl
  add    $0x1,%rax
  test   %cl,%cl
  jne    L355
  jmp    L380
  nopw   0x0(%rax,%rax,1)
L180:
  mov    0x6c(%rsp),%eax
  test   %eax,%eax
  cmovg  %eax,%ebx
  mov    %ebx,0x50(%rsp)
  jmp    L242
  nopw   0x0(%rax,%rax,1)
L278:
  cmp    %ebx,(%rsi,%rax,4)
  sete   %cl
  add    $0x1,%rax
  test   %cl,%cl
  jne    L4
  jmp    L217
  nop
L90:
  sub    $0x1,%ebp
  xor    %r8d,%r8d
  jmp    L380
L137:
  mov    0x38(%rsp),%rax
  movl   $0x0,0x50(%rsp)
  movq   $0x0,(%rax)
  movl   $0x0,0x8(%rax)
  jmp    L242
L267:
  sub    $0x8,%rsp
  mov    %r11d,%r9d
  push   $0x0
  mov    0xb8(%rsp),%eax
  push   %rax
  mov    0x88(%rsp),%eax
  push   %rax
  push   0xb0(%rsp)
  push   $0xc350
  mov    0xbc(%rsp),%eax
  push   %rax
  mov    0xc0(%rsp),%eax
  push   %rax
  push   0x78(%rsp)
  push   0x88(%rsp)
  mov    0x78(%rsp),%rcx
  mov    0x58(%rsp),%rdx
  mov    0x80(%rsp),%rsi
  mov    0x60(%rsp),%rdi
  call   <dist_2v_ordered_v2@plt>
  add    $0x50,%rsp
  mov    0x68(%rsp),%r10d
  jmp    L38
L229:
  sub    $0x1,%r13d
  xor    %r11d,%r11d
  jmp    L217
L429:
  cmp    %ecx,0xa4(%rsp)
  jl     L123
L152:
  test   %r11d,%r11d
  jle    L100
  movslq 0x50(%rsp),%rax
  mov    0x98(%rsp),%rdi
  lea    0x1(%r11),%r8d
  mov    $0x1,%esi
  mov    0x40(%rsp),%r9
  lea    (%rdi,%rax,8),%rdi
L450:
  mov    (%r9,%rsi,8),%rdx
  mov    (%rdi,%rsi,8),%rax
  add    $0x1,%rsi
  mov    %ebx,0x4(%rax)
  mov    0x4(%rdx),%r11d
  mov    %r11d,0x8(%rax)
  mov    0x8(%rdx),%r11d
  mov    %r11d,0xc(%rax)
  mov    0xc(%rdx),%r11d
  mov    %r11d,0x10(%rax)
  mov    0x10(%rdx),%r11d
  mov    %r11d,0x14(%rax)
  mov    0x14(%rdx),%r11d
  mov    %r11d,0x18(%rax)
  mov    0x18(%rdx),%edx
  mov    %edx,0x1c(%rax)
  cmp    %r8,%rsi
  jne    L450
  jmp    L333
L327:
  mov    %r11d,%esi
  xor    %eax,%eax
  lea    D2(%rip),%rdi
  mov    %r10d,0xb0(%rsp)
  mov    %r11d,0xac(%rsp)
  call   <printf@plt>
  mov    0xac(%rsp),%r11d
  mov    0xb0(%rsp),%r10d
  test   %r11d,%r11d
  jle    L260
  mov    %r10d,0xb8(%rsp)
  mov    $0x1,%r9d
  lea    D40(%rip),%rdi
  mov    %ebp,0xb0(%rsp)
  mov    0x40(%rsp),%rbp
  mov    %r13d,0xac(%rsp)
  mov    %r11d,%r13d
  mov    %ebx,0xb4(%rsp)
  mov    %r9,%rbx
L7:
  mov    0x0(%rbp,%rbx,8),%rax
  add    $0x1,%rbx
  mov    0xc(%rax),%ecx
  mov    0x8(%rax),%edx
  mov    0x4(%rax),%esi
  mov    0x10(%rax),%r8d
  xor    %eax,%eax
  call   <printf@plt>
  cmp    %ebx,%r13d
  lea    D40(%rip),%rdi
  jge    L7
  mov    %r13d,%r11d
  mov    0xb0(%rsp),%ebp
  mov    0xac(%rsp),%r13d
  mov    0xb4(%rsp),%ebx
  mov    0xb8(%rsp),%r10d
  jmp    L153
L359:
  mov    %ebx,%esi
  lea    D51(%rip),%rdi
  xor    %eax,%eax
  mov    %r8d,0x68(%rsp)
  mov    %r10d,0xb0(%rsp)
  mov    %r11d,0xac(%rsp)
  call   <printf@plt>
  mov    0x68(%rsp),%esi
  lea    D59(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x68(%rsp),%r8d
  mov    $0x1,%ecx
  mov    0xac(%rsp),%r11d
  mov    0xb0(%rsp),%r10d
  lea    D49(%rip),%rdi
  test   %r8d,%r8d
  je     L216
  mov    %r11d,0xb0(%rsp)
  mov    %r10d,0xbc(%rsp)
  mov    %ebx,0xb4(%rsp)
  mov    0x10(%rsp),%rbx
  mov    %r13d,0x68(%rsp)
  mov    %r8d,%r13d
  mov    %ebp,0xac(%rsp)
  mov    %rcx,%rbp
  mov    %r12d,0xb8(%rsp)
  mov    %rdi,%r12
L454:
  mov    0x8(%rsp),%rax
  mov    (%rbx,%rbp,4),%esi
  mov    %r12,%rdi
  movsbl (%rax,%rbp,1),%edx
  xor    %eax,%eax
  add    $0x1,%rbp
  call   <printf@plt>
  cmp    %ebp,%r13d
  jge    L454
  mov    %r13d,%r8d
  mov    0xac(%rsp),%ebp
  mov    0xb0(%rsp),%r11d
  mov    0x68(%rsp),%r13d
  mov    0xb4(%rsp),%ebx
  mov    0xb8(%rsp),%r12d
  mov    0xbc(%rsp),%r10d
L216:
  mov    $0xa,%edi
  mov    %r10d,0xb0(%rsp)
  mov    %r8d,0xac(%rsp)
  mov    %r11d,0x68(%rsp)
  call   <putchar@plt>
  mov    0x68(%rsp),%esi
  lea    D78(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x68(%rsp),%r11d
  mov    $0x1,%ecx
  mov    0xac(%rsp),%r8d
  mov    0xb0(%rsp),%r10d
  lea    D49(%rip),%rdi
  test   %r11d,%r11d
  je     L382
  mov    %r8d,0xb0(%rsp)
  mov    %r10d,0xbc(%rsp)
  mov    %ebx,0xb4(%rsp)
  mov    0x30(%rsp),%rbx
  mov    %r13d,0x68(%rsp)
  mov    %r11d,%r13d
  mov    %ebp,0xac(%rsp)
  mov    %rcx,%rbp
  mov    %r12d,0xb8(%rsp)
  mov    %rdi,%r12
L194:
  mov    0x28(%rsp),%rax
  mov    (%rbx,%rbp,4),%esi
  mov    %r12,%rdi
  movsbl (%rax,%rbp,1),%edx
  xor    %eax,%eax
  add    $0x1,%rbp
  call   <printf@plt>
  cmp    %ebp,%r13d
  jge    L194
  mov    %r13d,%r11d
  mov    0xac(%rsp),%ebp
  mov    0x68(%rsp),%r13d
  mov    0xb0(%rsp),%r8d
  mov    0xb4(%rsp),%ebx
  mov    0xb8(%rsp),%r12d
  mov    0xbc(%rsp),%r10d
L382:
  mov    $0xa,%edi
  mov    %r10d,0xb0(%rsp)
  mov    %r8d,0xac(%rsp)
  mov    %r11d,0x68(%rsp)
  call   <putchar@plt>
  mov    0x68(%rsp),%r11d
  mov    0xac(%rsp),%r8d
  mov    0xb0(%rsp),%r10d
  jmp    L156
L123:
  mov    %eax,%esi
  mov    0x68(%rsp),%eax
  lea    D37(%rip),%rdi
  mov    %r10d,0xb0(%rsp)
  mov    %ecx,0xac(%rsp)
  sub    $0x1,%eax
  mov    %r11d,0x6c(%rsp)
  mov    %eax,0x54(%rsp)
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x6c(%rsp),%r11d
  lea    D34(%rip),%rdi
  xor    %eax,%eax
  mov    %r11d,%esi
  mov    %r11d,0x68(%rsp)
  call   <printf@plt>
  lea    D88(%rip),%rdi
  call   <puts@plt>
  mov    0x50(%rsp),%eax
  movl   $0x0,0x70(%rsp)
  mov    0xb0(%rsp),%r10d
  mov    0xac(%rsp),%ecx
  mov    %eax,0x6c(%rsp)
  mov    0x68(%rsp),%r11d
  jmp    L152
L100:
  mov    %ebx,%r9d
  mov    %ebx,%esi
  jmp    L258
```

tool_calls: name: parse_data
arguments: data_label: D2
datatype: string
name: parse_data
arguments: data_label: D40
datatype: string
name: parse_data
arguments: data_label: D51
datatype: string
name: parse_data
arguments: data_label: D59
datatype: string
name: parse_data
arguments: data_label: D49
datatype: string
name: parse_data
arguments: data_label: D78
datatype: string
name: parse_data
arguments: data_label: D37
datatype: string
name: parse_data
arguments: data_label: D34
datatype: string
name: parse_data
arguments: data_label: D88
datatype: string

tool: D2: ovdi_single_transcript (%d)


tool: D40: %d %d %d %d


tool: D51: transcript=%d


tool: D59: motif 1 (%d): 

tool: D49: %d %d,

tool: D78: motif 2 (%d): 

tool: D37: running_entries=%d


tool: D34: n12=%d


tool: D88: setting get_positions to 0

assistant: ```c
void dist_2v_allt_v2(int *m1_t, int *m2_t, int *m1_p, int *m2_p, char *m1_s, char *m2_s, int n1, int n2, int **ovdi, int *n, int min_dist, int max_dist, int n_transcripts, int *ml, int get_positions, int order_constraint, int max_n_transcripts, int max_n_ovdi, int pos_format, int verbose) {
  int **ovdi_single_transcript;
  int *m1p;
  char *m1s;
  int *m2p;
  char *m2s;
  int curr_n1, curr_n2;
  int curr_tr1, curr_tr2;
  int errorcode = 0;
  int i, j;
  int i1, i2;
  int max_n_ovdi_single_transcript = 50000;
  int max_transcript_occurrences = 10000;
  int n12;
  int n12_stop = 0;
  int n12_tr = 0;
  int running_entries = 0;
  int transcript = 0;
  i1 = 1;
  curr_tr1 = m1_t[i1];
  i2 = 1;
  curr_tr2 = m2_t[i2];
  m1p = ivector(1, max_transcript_occurrences);
  m1s = cvector(1, max_transcript_occurrences);
  m2p = ivector(1, max_transcript_occurrences);
  m2s = cvector(1, max_transcript_occurrences);
  ovdi_single_transcript = imatrix(1, max_n_ovdi_single_transcript, 1, 6);
  if (max_n_transcripts < 0)
    max_n_transcripts = n_transcripts + 1;
  while ((transcript < n_transcripts) & (n12_tr <= max_n_transcripts)) {
    transcript++;
    if ((curr_tr1 < 0) | (curr_tr2 < 0))
      transcript = n_transcripts + 1;
    while ((curr_tr1 < transcript) & (curr_tr1 >= 0) & (i1 < n1)) {
      i1++;
      curr_tr1 = m1_t[i1];
    }
    if (curr_tr1 == transcript) {
      curr_n1 = 0;
      while ((curr_tr1 == transcript) & (i1 <= n1)) {
        curr_n1++;
        m1p[curr_n1] = m1_p[i1];
        m1s[curr_n1] = m1_s[i1];
        i1++;
        if (i1 <= n1)
          curr_tr1 = m1_t[i1];
      }
      i1--;
      curr_tr1 = transcript;
      while ((curr_tr2 < transcript) & (curr_tr2 >= 0) & (i2 < n2)) {
        i2++;
        curr_tr2 = m2_t[i2];
      }
      if (curr_tr2 == transcript) {
        curr_n2 = 0;
        while ((curr_tr2 == transcript) & (i2 <= n2)) {
          curr_n2++;
          m2p[curr_n2] = m2_p[i2];
          m2s[curr_n2] = m2_s[i2];
          i2++;
          if (i2 <= n2)
            curr_tr2 = m2_t[i2];
        }
        i2--;
        curr_tr2 = transcript;
        if (verbose) {
          printf("transcript=%d\n", transcript);
          printf("motif 1 (%d): ", curr_n1);
          for (i = 1; i <= curr_n1; i++)
            printf("%d %d,", m1p[i], m1s[i]);
          printf("\n");
          printf("motif 2 (%d): ", curr_n2);
          for (i = 1; i <= curr_n2; i++)
            printf("%d %d,", m2p[i], m2s[i]);
          printf("\n");
        }
        if (order_constraint == 1) {
          dist_2v_ordered_v2(m1p, m2p, m1s, m2s, curr_n1, curr_n2, ovdi_single_transcript, n, min_dist, max_dist, max_n_ovdi_single_transcript, ml, get_positions, pos_format, 0);
        } else {
          dist_2v_unordered_v3(m1p, m2p, m1s, m2s, curr_n1, curr_n2, ovdi_single_transcript, n, min_dist, max_dist, max_n_ovdi_single_transcript, ml, get_positions);
        }
        n12 = n[0];
        errorcode += n[1];
        if (verbose) {
          printf("ovdi_single_transcript (%d)\n", n12);
          for (i = 1; i <= n12; i++)
            printf("%d %d %d %d\n", ovdi_single_transcript[i][1], ovdi_single_transcript[i][2], ovdi_single_transcript[i][3], ovdi_single_transcript[i][4]);
        }
        if (n12 > 0)
          n12_tr++;
        if (get_positions == 1) {
          if ((running_entries + n12) > max_n_ovdi) {
            get_positions = 0;
            errorcode--;
            n12_stop = running_entries;
            printf("running_entries=%d\n", running_entries);
            printf("n12=%d\n", n12);
            printf("setting get_positions to 0\n");
          }
          for (i = 1; i <= n12; i++) {
            running_entries++;
            ovdi[running_entries][1] = transcript;
            ovdi[running_entries][2] = ovdi_single_transcript[i][1];
            ovdi[running_entries][3] = ovdi_single_transcript[i][2];
            ovdi[running_entries][4] = ovdi_single_transcript[i][3];
            ovdi[running_entries][5] = ovdi_single_transcript[i][4];
            ovdi[running_entries][6] = ovdi_single_transcript[i][5];
            ovdi[running_entries][7] = ovdi_single_transcript[i][6];
          }
        } else {
          running_entries += n12;
        }
      }
    }
  }
  n[0] = running_entries;
  n[1] = n12_tr;
  n[2] = errorcode;
  if (errorcode < 0) {
    if (n12_stop <= 0)
      n12_stop = running_entries;
    n[3] = n12_stop;
  } else {
    n[3] = running_entries;
  }
  free_ivector(m1p, 1, max_transcript_occurrences);
  free_cvector(m1s, 1, max_transcript_occurrences);
  free_ivector(m2p, 1, max_transcript_occurrences);
  free_cvector(m2s, 1, max_transcript_occurrences);
  free_imatrix(ovdi_single_transcript, 1, max_n_ovdi_single_transcript, 1, 6);
}
```