#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
char *cvector(int, int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, int, int, float,
                           char *, int);
int /*<<< orphan*/ free_cvector(char *, int, int);
int /*<<< orphan*/ num2seq(char *, int, char *, int);
int /*<<< orphan*/ revcomp(char *, char *, int);
int /*<<< orphan*/ sprintf(char *, char *);
int scan_motif3(float **weight_matrix, char *sequence, int motif_length,
                int seq_length, float threshold, int *pos, char *strand, int rc,
                FILE *log_file, int seq_nr) {
  int i, j, k;
  int i_stop;
  char c;
  float p;
  int n;
  float current_score;
  char *revcomp_seq;
  int curr_strand;
  char *word;
  char *numword;
  i_stop = seq_length - motif_length;
  n = 0;
  numword = cvector(1, motif_length);
  word = cvector(0, motif_length - 1);
  curr_strand = 1;
  for (i = 1; i <= i_stop; i++) {
    current_score = 0.0;
    for (j = 1; j <= motif_length; j++) {
      c = sequence[i + j - 1];
      if ((c > 0) & (c < 5)) {
        p = weight_matrix[c][j];
        current_score += p;
      } else {
        current_score += -7.6;
      }
    }
    if (current_score >= threshold) {
      n++;
      pos[n] = seq_length - i;
      strand[n] = curr_strand;
      for (j = 1; j <= motif_length; j++)
        numword[j] = sequence[i + j - 1];
      sprintf(word, "");
      num2seq(numword, motif_length, word, 1);
      fprintf(log_file, "%d\t%d\t%.4f\t%s\t%d\n", seq_nr, pos[n], current_score,
              word, curr_strand);
    }
  }
  curr_strand = 0;
  if (rc == 1) {
    revcomp_seq = cvector(1, seq_length);
    revcomp(sequence, revcomp_seq, seq_length);
    for (i = 1; i <= i_stop; i++) {
      current_score = 0;
      for (j = 1; j <= motif_length; j++) {
        c = revcomp_seq[i + j - 1];
        if ((c > 0) & (c < 5)) {
          p = weight_matrix[c][j];
          current_score += p;
        } else {
          current_score += -7.6;
        }
      }
      if (current_score >= threshold) {
        n++;
        pos[n] = i;
        strand[n] = 0;
        for (j = 1; j <= motif_length; j++)
          numword[j] = revcomp_seq[i + j - 1];
        sprintf(word, "");
        num2seq(numword, motif_length, word, 1);
        fprintf(log_file, "%d\t%d\t%.4f\t%s\t%d\n", seq_nr, pos[n],
                current_score, word, curr_strand);
      }
    }
    free_cvector(revcomp_seq, 1, seq_length);
  }
  free_cvector(numword, 1, motif_length);
  free_cvector(word, 0, motif_length - 1);
  return n;
}


x86 assembly (clang, -O0):
<scan_motif3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1030 <cvector@plt>
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1030 <cvector@plt>
mov    %rax,-0x68(%rbp)
movl   $0x1,-0x5c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     136f <scan_motif3+0x20f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1294 <scan_motif3+0x134>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x41(%rbp)
movsbl -0x41(%rbp),%eax
cmp    $0x0,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x41(%rbp),%ecx
cmp    $0x5,%ecx
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1263 <scan_motif3+0x103>
mov    -0x8(%rbp),%rax
movsbq -0x41(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
jmp    1281 <scan_motif3+0x121>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd8c(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
jmp    1286 <scan_motif3+0x126>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11e8 <scan_motif3+0x88>
movss  -0x50(%rbp),%xmm0
ucomiss -0x1c(%rbp),%xmm0
jb     135c <scan_motif3+0x1fc>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%edx
sub    -0x34(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     130c <scan_motif3+0x1ac>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12d4 <scan_motif3+0x174>
mov    -0x68(%rbp),%rdi
lea    0xd02(%rip),%rsi
call   1070 <sprintf@plt>
mov    -0x70(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    $0x1,%ecx
call   1050 <num2seq@plt>
mov    0x18(%rbp),%rdi
mov    0x20(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movss  -0x50(%rbp),%xmm0
mov    -0x68(%rbp),%r8
mov    -0x5c(%rbp),%r9d
lea    0xcb1(%rip),%rsi
call   1040 <fprintf@plt>
jmp    1361 <scan_motif3+0x201>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11cd <scan_motif3+0x6d>
movl   $0x0,-0x5c(%rbp)
cmpl   $0x1,0x10(%rbp)
jne    1554 <scan_motif3+0x3f4>
mov    -0x18(%rbp),%esi
mov    $0x1,%edi
call   1030 <cvector@plt>
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x18(%rbp),%edx
call   1080 <revcomp@plt>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1543 <scan_motif3+0x3e3>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     146f <scan_motif3+0x30f>
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x41(%rbp)
movsbl -0x41(%rbp),%eax
cmp    $0x0,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x41(%rbp),%ecx
cmp    $0x5,%ecx
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     143e <scan_motif3+0x2de>
mov    -0x8(%rbp),%rax
movsbq -0x41(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
jmp    145c <scan_motif3+0x2fc>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbb1(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
jmp    1461 <scan_motif3+0x301>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13c3 <scan_motif3+0x263>
movss  -0x50(%rbp),%xmm0
ucomiss -0x1c(%rbp),%xmm0
jb     1530 <scan_motif3+0x3d0>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     14e0 <scan_motif3+0x380>
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14a8 <scan_motif3+0x348>
mov    -0x68(%rbp),%rdi
lea    0xb2e(%rip),%rsi
call   1070 <sprintf@plt>
mov    -0x70(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    $0x1,%ecx
call   1050 <num2seq@plt>
mov    0x18(%rbp),%rdi
mov    0x20(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movss  -0x50(%rbp),%xmm0
mov    -0x68(%rbp),%r8
mov    -0x5c(%rbp),%r9d
lea    0xadd(%rip),%rsi
call   1040 <fprintf@plt>
jmp    1535 <scan_motif3+0x3d5>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13a8 <scan_motif3+0x248>
mov    -0x58(%rbp),%rdi
mov    -0x18(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_cvector@plt>
mov    -0x70(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_cvector@plt>
mov    -0x68(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1060 <free_cvector@plt>
mov    -0x4c(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scan_motif3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r9,0x78(%rsp)
mov    %r8,0x70(%rsp)
movss  %xmm0,0x34(%rsp)
mov    %ecx,%ebp
mov    %edx,%ebx
mov    %rsi,%r14
mov    %rdi,%r15
mov    $0x1,%edi
mov    %edx,%esi
call   1030 <cvector@plt>
mov    %rax,0x48(%rsp)
lea    -0x1(%rbx),%esi
xor    %eax,%eax
mov    %rax,0x8(%rsp)
xor    %edi,%edi
mov    %esi,0x6c(%rsp)
call   1030 <cvector@plt>
mov    %rbx,%r11
mov    %rax,0xe8(%rsp)
mov    %ebp,0x30(%rsp)
mov    %ebp,%r10d
sub    %r11d,%r10d
mov    %rbx,0xf0(%rsp)
mov    %r15,0xe0(%rsp)
jle    16e2 <scan_motif3+0x592>
mov    %r15,%rbx
movabs $0x2100000000,%rbp
movabs $0x100000000,%r15
lea    0x1(%r11),%r13d
add    $0x1,%r10d
lea    -0x2(%r13),%rax
mov    %rax,0xc0(%rsp)
mov    0x48(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0xb8(%rsp)
add    %r13,%rax
mov    %rax,0xb0(%rsp)
lea    -0x1(%r13),%rax
lea    -0x1(%r14,%r13,1),%rcx
mov    %rcx,0xd8(%rsp)
lea    -0x21(%r13),%rcx
mov    %rcx,0xa0(%rsp)
mov    %rcx,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %rax,%rsi
and    $0xffffffffffffffe0,%rsi
mov    %rdx,%rcx
mov    %rdx,0x98(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x88(%rsp)
mov    %rax,0xd0(%rsp)
and    $0xfffffffffffffff8,%rax
mov    %r13,%rcx
neg    %rcx
mov    %rcx,0xc8(%rsp)
movsd  0xd85(%rip),%xmm1
mov    %rsi,0x90(%rsp)
lea    0x1(%rsi),%rcx
mov    %rcx,0x80(%rsp)
mov    %rax,0x58(%rsp)
add    $0x1,%rax
mov    %rax,0xa8(%rsp)
lea    0x1(%r15),%rcx
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    $0x1,%edx
mov    %r15,%rax
mov    %r15,%rdi
mov    %r10,0x40(%rsp)
jmp    12ea <scan_motif3+0x19a>
nopl   (%rax)
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%rax
mov    0x20(%rsp),%rdi
add    $0x1,%rdx
add    $0x1,%rax
add    %r15,%rdi
add    %r15,%rbp
add    $0x1,%rcx
cmp    %r10,%rdx
je     16e2 <scan_motif3+0x592>
test   %r11d,%r11d
jle    1480 <scan_motif3+0x330>
mov    %rcx,0x10(%rsp)
mov    %rax,%rcx
mov    %rax,0x28(%rsp)
lea    0x1(%rax),%r9d
movslq %r9d,%r8
lea    (%r14,%r8,1),%r12
add    0xd8(%rsp),%r8
xorps  %xmm0,%xmm0
mov    $0x1,%eax
mov    %rdi,0x20(%rsp)
jmp    1348 <scan_motif3+0x1f8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
add    $0x1,%rax
add    %r15,%rdi
cmp    %rax,%r13
je     1370 <scan_motif3+0x220>
mov    %rdi,%rcx
sar    $0x20,%rcx
movzbl (%r14,%rcx,1),%ecx
lea    -0x1(%rcx),%esi
cmp    $0x3,%sil
ja     1330 <scan_motif3+0x1e0>
mov    (%rbx,%rcx,8),%rcx
addss  (%rcx,%rax,4),%xmm0
jmp    133c <scan_motif3+0x1ec>
nopl   0x0(%rax,%rax,1)
ucomiss 0x34(%rsp),%xmm0
jb     12c0 <scan_motif3+0x170>
mov    %r12,%r10
movslq 0x8(%rsp),%rax
lea    0x1(%rax),%rbx
mov    0x30(%rsp),%ecx
sub    %edx,%ecx
mov    0x70(%rsp),%rsi
lea    (%rsi,%rax,4),%r12
add    $0x4,%r12
mov    %ecx,0x4(%rsi,%rax,4)
mov    0x78(%rsp),%rcx
movb   $0x1,0x1(%rcx,%rax,1)
test   %r11d,%r11d
mov    0x48(%rsp),%rdi
mov    %rbx,0x8(%rsp)
mov    %rbp,0x38(%rsp)
mov    %rdx,0x60(%rsp)
movss  %xmm0,0x1c(%rsp)
jle    14e4 <scan_motif3+0x394>
mov    %r12,0x50(%rsp)
lea    (%r15,%rdx,1),%rbp
add    $0xffffffffffffffff,%rbp
mov    $0x1,%esi
mov    0xd0(%rsp),%r12
cmp    $0x8,%r12
jae    1567 <scan_motif3+0x417>
mov    %rsi,%rcx
test   $0x1,%r13b
jne    1408 <scan_motif3+0x2b8>
add    %esi,%ebp
movslq %ebp,%rax
mov    (%r14,%rax,1),%al
mov    %al,(%rdi,%rsi,1)
lea    0x1(%rsi),%rcx
not    %rsi
cmp    0xc8(%rsp),%rsi
je     1476 <scan_motif3+0x326>
mov    0x28(%rsp),%rax
add    %ecx,%eax
shl    $0x20,%rax
mov    0x10(%rsp),%rdx
add    %ecx,%edx
shl    $0x20,%rdx
movabs $0x200000000,%rbp
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,%rsi
sar    $0x20,%rsi
movzbl (%r14,%rsi,1),%ebx
mov    %bl,(%rdi,%rcx,1)
mov    %rdx,%rsi
sar    $0x20,%rsi
movzbl (%r14,%rsi,1),%ebx
mov    %bl,0x1(%rdi,%rcx,1)
add    $0x2,%rcx
add    %rbp,%rax
add    %rbp,%rdx
cmp    %rcx,%r13
jne    1440 <scan_motif3+0x2f0>
mov    0xf0(%rsp),%r11
mov    0x50(%rsp),%r12
jmp    14e4 <scan_motif3+0x394>
nopl   (%rax)
xorps  %xmm0,%xmm0
ucomiss 0x34(%rsp),%xmm0
jb     12cf <scan_motif3+0x17f>
mov    %rdi,0x20(%rsp)
mov    %rax,0x28(%rsp)
mov    %rcx,0x10(%rsp)
mov    %rbp,0x38(%rsp)
movslq 0x8(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x8(%rsp)
mov    0x70(%rsp),%rsi
lea    (%rsi,%rax,4),%r12
add    $0x4,%r12
mov    0x30(%rsp),%ecx
mov    %rdx,0x60(%rsp)
sub    %edx,%ecx
mov    %ecx,0x4(%rsi,%rax,4)
mov    0x78(%rsp),%rcx
movb   $0x1,0x1(%rcx,%rax,1)
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rsp)
mov    0x48(%rsp),%rdi
mov    0xe8(%rsp),%rbp
movb   $0x0,0x0(%rbp)
mov    %r11d,%esi
mov    %rbp,%rdx
mov    $0x1,%ecx
mov    %r11,%rbx
call   1050 <num2seq@plt>
mov    (%r12),%ecx
mov    0x138(%rsp),%rdi
lea    0xaf6(%rip),%rsi
mov    0x140(%rsp),%edx
movss  0x1c(%rsp),%xmm0
mov    %rbp,%r8
mov    $0x1,%r9d
call   1040 <fprintf@plt>
mov    %rbx,%r11
mov    0xe0(%rsp),%rbx
mov    0x40(%rsp),%r10
mov    0x38(%rsp),%rbp
movsd  0xab2(%rip),%xmm1
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%rax
mov    0x20(%rsp),%rdi
mov    0x60(%rsp),%rdx
jmp    12cf <scan_motif3+0x17f>
mov    0xc0(%rsp),%rax
lea    (%r9,%rax,1),%ecx
cmp    %r9d,%ecx
jl     13ef <scan_motif3+0x29f>
mov    %rax,%rcx
shr    $0x20,%rcx
jne    13ef <scan_motif3+0x29f>
cmp    %r8,0xb8(%rsp)
mov    0x58(%rsp),%rbx
jae    15a6 <scan_motif3+0x456>
cmp    0xb0(%rsp),%r10
jb     13ef <scan_motif3+0x29f>
cmp    $0x20,%r12
jae    15b3 <scan_motif3+0x463>
xor    %ecx,%ecx
jmp    168e <scan_motif3+0x53e>
mov    %rbp,%r8
cmpq   $0x20,0xa0(%rsp)
jae    15c5 <scan_motif3+0x475>
xor    %ecx,%ecx
jmp    163a <scan_motif3+0x4ea>
mov    0x88(%rsp),%rdx
mov    0x20(%rsp),%rax
mov    0x38(%rsp),%rbx
xor    %ecx,%ecx
movabs $0x4000000000,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,%rsi
sar    $0x20,%rsi
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,0x1(%rdi,%rcx,1)
movups %xmm1,0x11(%rdi,%rcx,1)
mov    %rbx,%rsi
sar    $0x20,%rsi
movups (%r14,%rsi,1),%xmm0
movupd 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,0x21(%rdi,%rcx,1)
movupd %xmm1,0x31(%rdi,%rcx,1)
add    $0x40,%rcx
add    %rbp,%rbx
add    %rbp,%rax
add    $0xfffffffffffffffe,%rdx
jne    15f0 <scan_motif3+0x4a0>
testb  $0x1,0x98(%rsp)
01
mov    0x58(%rsp),%rbx
mov    %r8,%rbp
je     166b <scan_motif3+0x51b>
or     $0x1,%rcx
lea    (%rcx,%rbp,1),%eax
cltq
movups (%r14,%rax,1),%xmm0
movupd 0x10(%r14,%rax,1),%xmm1
movups %xmm0,(%rdi,%rcx,1)
movupd %xmm1,0x10(%rdi,%rcx,1)
mov    0x90(%rsp),%rcx
cmp    %rcx,%r12
je     1476 <scan_motif3+0x326>
mov    0x80(%rsp),%rsi
test   $0x18,%r12b
je     13ef <scan_motif3+0x29f>
mov    0x10(%rsp),%rax
lea    (%rcx,%rax,1),%edx
shl    $0x20,%rdx
movabs $0x800000000,%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdx,%rax
sar    $0x20,%rax
mov    (%r14,%rax,1),%rax
mov    %rax,0x1(%rdi,%rcx,1)
add    $0x8,%rcx
add    %rsi,%rdx
cmp    %rcx,%rbx
jne    16b0 <scan_motif3+0x560>
mov    0xa8(%rsp),%rsi
cmp    %rbx,%r12
jne    13ef <scan_motif3+0x29f>
jmp    1476 <scan_motif3+0x326>
cmpl   $0x1,0x130(%rsp)
01
jne    1c21 <scan_motif3+0xad1>
mov    $0x1,%edi
mov    0x30(%rsp),%ebp
mov    %ebp,%esi
mov    %r11,%rbx
call   1030 <cvector@plt>
mov    %rax,%r13
mov    %r14,%rdi
mov    %rax,%rsi
mov    %ebp,%edx
call   1070 <revcomp@plt>
mov    %rbx,%r10
mov    %ebp,%r11d
sub    %r10d,%r11d
jle    1c2c <scan_motif3+0xadc>
movabs $0x2100000000,%rax
movabs $0x100000000,%r14
lea    0x1(%r10),%r12d
add    $0x1,%r11d
lea    -0x2(%r12),%rcx
mov    %rcx,0xd0(%rsp)
mov    0x48(%rsp),%rdi
lea    0x1(%rdi),%rcx
mov    %rcx,0xb8(%rsp)
mov    %rdi,%rcx
add    %r12,%rcx
mov    %rcx,0xb0(%rsp)
lea    -0x1(%r12),%rbp
lea    (%r12,%r13,1),%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,0xd8(%rsp)
lea    -0x21(%r12),%rdx
mov    %rdx,0xa0(%rsp)
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %rbp,%rcx
and    $0xffffffffffffffe0,%rcx
mov    %rsi,%rdx
mov    %rsi,0x98(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x88(%rsp)
mov    %rbp,0xc8(%rsp)
and    $0xfffffffffffffff8,%rbp
mov    %r12,%rdx
neg    %rdx
mov    %rdx,0xc0(%rsp)
movsd  0x829(%rip),%xmm1
mov    %rcx,0x90(%rsp)
add    $0x1,%rcx
mov    %rcx,0x80(%rsp)
mov    %rbp,0x58(%rsp)
lea    0x1(%rbp),%rcx
mov    %rcx,0xa8(%rsp)
lea    0x1(%r14),%rcx
mov    $0x1,%r15d
mov    %r14,%rdx
mov    %r14,%rbp
mov    0xe0(%rsp),%rbx
mov    %r11,0x50(%rsp)
jmp    184f <scan_motif3+0x6ff>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%rdx
mov    0x38(%rsp),%rbp
add    $0x1,%r15
add    $0x1,%rdx
add    %r14,%rbp
add    %r14,%rax
add    $0x1,%rcx
cmp    %r11,%r15
je     1c2c <scan_motif3+0xadc>
test   %r10d,%r10d
jle    19a0 <scan_motif3+0x850>
mov    %rcx,0x10(%rsp)
mov    %rax,0x20(%rsp)
mov    %rdx,%rax
mov    %rdx,0x28(%rsp)
lea    0x1(%rdx),%r9d
movslq %r9d,%rdx
lea    (%rdx,%r13,1),%r8
add    0xd8(%rsp),%rdx
xorps  %xmm2,%xmm2
mov    $0x1,%eax
mov    %rbp,0x38(%rsp)
jmp    18ae <scan_motif3+0x75e>
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm2,%xmm2
cvtsd2ss %xmm0,%xmm2
add    $0x1,%rax
add    %r14,%rbp
cmp    %rax,%r12
je     18d0 <scan_motif3+0x780>
mov    %rbp,%rcx
sar    $0x20,%rcx
movzbl 0x0(%r13,%rcx,1),%ecx
lea    -0x1(%rcx),%esi
cmp    $0x3,%sil
ja     1890 <scan_motif3+0x740>
mov    (%rbx,%rcx,8),%rcx
addss  (%rcx,%rax,4),%xmm2
jmp    18a2 <scan_motif3+0x752>
nop
ucomiss 0x34(%rsp),%xmm2
jb     1820 <scan_motif3+0x6d0>
movslq 0x8(%rsp),%rax
lea    0x1(%rax),%rbp
mov    0x70(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
add    $0x4,%rsi
mov    %rsi,0x40(%rsp)
mov    %r15d,0x4(%rcx,%rax,4)
mov    0x78(%rsp),%rcx
movb   $0x0,0x1(%rcx,%rax,1)
test   %r10d,%r10d
mov    %rbp,0x8(%rsp)
mov    %r15,0x60(%rsp)
movss  %xmm2,0x1c(%rsp)
jle    1b98 <scan_motif3+0xa48>
lea    (%r14,%r15,1),%rax
add    $0xffffffffffffffff,%rax
mov    $0x1,%esi
mov    0xc8(%rsp),%r11
cmp    $0x8,%r11
mov    0xd0(%rsp),%rbx
jb     1b1a <scan_motif3+0x9ca>
lea    (%r9,%rbx,1),%ecx
cmp    %r9d,%ecx
jl     1b1a <scan_motif3+0x9ca>
mov    %rbx,%rcx
shr    $0x20,%rcx
jne    1b1a <scan_motif3+0x9ca>
cmp    %rdx,0xb8(%rsp)
mov    0x58(%rsp),%rbp
movabs $0x800000000,%rbx
jae    1986 <scan_motif3+0x836>
cmp    0xb0(%rsp),%r8
jb     1b1a <scan_motif3+0x9ca>
cmp    $0x20,%r11
jae    19fe <scan_motif3+0x8ae>
xor    %ecx,%ecx
jmp    1ad8 <scan_motif3+0x988>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm0,%xmm0
ucomiss 0x34(%rsp),%xmm0
jb     1834 <scan_motif3+0x6e4>
mov    %rbp,0x38(%rsp)
mov    %rdx,0x28(%rsp)
mov    %rcx,0x10(%rsp)
mov    %rax,0x20(%rsp)
movslq 0x8(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x8(%rsp)
mov    0x70(%rsp),%rcx
mov    %r15,%rdx
lea    0x4(%rcx,%rax,4),%r15
mov    %rdx,0x60(%rsp)
mov    %edx,0x4(%rcx,%rax,4)
mov    0x78(%rsp),%rcx
movb   $0x0,0x1(%rcx,%rax,1)
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rsp)
jmp    1b9d <scan_motif3+0xa4d>
mov    %rax,%r8
cmpq   $0x20,0xa0(%rsp)
jae    1a10 <scan_motif3+0x8c0>
xor    %ecx,%ecx
jmp    1a7c <scan_motif3+0x92c>
mov    0x88(%rsp),%rdx
mov    0x38(%rsp),%rbp
mov    0x20(%rsp),%rbx
xor    %ecx,%ecx
movabs $0x4000000000,%rax
xchg   %ax,%ax
mov    %rbp,%rsi
sar    $0x20,%rsi
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,0x1(%rdi,%rcx,1)
movups %xmm1,0x11(%rdi,%rcx,1)
mov    %rbx,%rsi
sar    $0x20,%rsi
movups 0x0(%r13,%rsi,1),%xmm0
movupd 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,0x21(%rdi,%rcx,1)
movupd %xmm1,0x31(%rdi,%rcx,1)
add    $0x40,%rcx
add    %rax,%rbx
add    %rax,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1a30 <scan_motif3+0x8e0>
testb  $0x1,0x98(%rsp)
01
mov    0x58(%rsp),%rbp
movabs $0x800000000,%rbx
mov    %r8,%rax
je     1ab9 <scan_motif3+0x969>
or     $0x1,%rcx
lea    (%rcx,%rax,1),%edx
movslq %edx,%rdx
movups 0x0(%r13,%rdx,1),%xmm0
movupd 0x10(%r13,%rdx,1),%xmm1
movups %xmm0,(%rdi,%rcx,1)
movupd %xmm1,0x10(%rdi,%rcx,1)
mov    0x90(%rsp),%rcx
cmp    %rcx,%r11
je     1b98 <scan_motif3+0xa48>
mov    0x80(%rsp),%rsi
test   $0x18,%r11b
je     1b1a <scan_motif3+0x9ca>
mov    0x10(%rsp),%rdx
add    %ecx,%edx
shl    $0x20,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdx,%rsi
sar    $0x20,%rsi
mov    0x0(%r13,%rsi,1),%rsi
mov    %rsi,0x1(%rdi,%rcx,1)
add    $0x8,%rcx
add    %rbx,%rdx
cmp    %rcx,%rbp
jne    1af0 <scan_motif3+0x9a0>
mov    0xa8(%rsp),%rsi
cmp    %rbp,%r11
je     1b98 <scan_motif3+0xa48>
mov    %rsi,%rcx
test   $0x1,%r12b
jne    1b33 <scan_motif3+0x9e3>
add    %esi,%eax
cltq
mov    0x0(%r13,%rax,1),%al
mov    %al,(%rdi,%rsi,1)
lea    0x1(%rsi),%rcx
not    %rsi
cmp    0xc0(%rsp),%rsi
je     1b98 <scan_motif3+0xa48>
mov    0x28(%rsp),%rax
add    %ecx,%eax
shl    $0x20,%rax
mov    0x10(%rsp),%rdx
add    %ecx,%edx
shl    $0x20,%rdx
movabs $0x200000000,%rbp
mov    %rax,%rsi
sar    $0x20,%rsi
movzbl 0x0(%r13,%rsi,1),%ebx
mov    %bl,(%rdi,%rcx,1)
mov    %rdx,%rsi
sar    $0x20,%rsi
movzbl 0x0(%r13,%rsi,1),%ebx
mov    %bl,0x1(%rdi,%rcx,1)
add    $0x2,%rcx
add    %rbp,%rax
add    %rbp,%rdx
cmp    %rcx,%r12
jne    1b60 <scan_motif3+0xa10>
mov    0xf0(%rsp),%r10
mov    0x40(%rsp),%r15
mov    0xe8(%rsp),%rbp
movb   $0x0,0x0(%rbp)
mov    %r10d,%esi
mov    %rbp,%rdx
mov    $0x1,%ecx
mov    %r10,%rbx
call   1050 <num2seq@plt>
mov    (%r15),%ecx
mov    0x138(%rsp),%rdi
lea    0x43e(%rip),%rsi
mov    0x140(%rsp),%edx
movss  0x1c(%rsp),%xmm0
mov    %rbp,%r8
xor    %r9d,%r9d
call   1040 <fprintf@plt>
mov    %rbx,%r10
mov    0x48(%rsp),%rdi
mov    0xe0(%rsp),%rbx
mov    0x50(%rsp),%r11
mov    0x20(%rsp),%rax
movsd  0x3f8(%rip),%xmm1
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%rdx
mov    0x38(%rsp),%rbp
mov    0x60(%rsp),%r15
jmp    1834 <scan_motif3+0x6e4>
mov    0x6c(%rsp),%ebp
mov    0x48(%rsp),%rdi
jmp    1c4c <scan_motif3+0xafc>
mov    %r13,%rdi
mov    $0x1,%esi
mov    0x30(%rsp),%edx
mov    %r10,%rbx
call   1060 <free_cvector@plt>
mov    %rbx,%r11
mov    0x48(%rsp),%rdi
mov    0x6c(%rsp),%ebp
mov    0x8(%rsp),%rbx
mov    $0x1,%esi
mov    %r11d,%edx
call   1060 <free_cvector@plt>
mov    0xe8(%rsp),%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1060 <free_cvector@plt>
mov    %ebx,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [1 x i8] zeroinitializer
@.str.1 = [18 x i8] c"%d\09%d\09%.4f\09%s\09%d\0A\00"
define i32 @scan_motif3(float** %0, i8* %1, i32 %2, i32 %3, float %4, i32* %5, i8* %6, i32 %7, i32* %8, i32 %9) {
%11 = alloca float**
%12 = alloca i8*
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca i32*
%17 = alloca i8*
%18 = alloca i32
%19 = alloca i32*
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i8
%26 = alloca float
%27 = alloca i32
%28 = alloca float
%29 = alloca i8*
%30 = alloca i32
%31 = alloca i8*
%32 = alloca i8*
store float** %0, float*** %11
store i8* %1, i8** %12
store i32 %2, i32* %13
store i32 %3, i32* %14
store float %4, float* %15
store i32* %5, i32** %16
store i8* %6, i8** %17
store i32 %7, i32* %18
store i32* %8, i32** %19
store i32 %9, i32* %20
%33 = load i32, i32* %14
%34 = load i32, i32* %13
%35 = sub nsw i32 %33, %34
store i32 %35, i32* %24
store i32 0, i32* %27
%36 = load i32, i32* %13
%37 = call i8* @cvector(i32 1, i32 %36)
store i8* %37, i8** %32
%38 = load i32, i32* %13
%39 = sub nsw i32 %38, 1
%40 = call i8* @cvector(i32 0, i32 %39)
store i8* %40, i8** %31
store i32 1, i32* %30
store i32 1, i32* %21
br label %41
41: ; preds = %150, %10
%42 = load i32, i32* %21
%43 = load i32, i32* %24
%44 = icmp sle i32 %42, %43
br i1 %44, label %45, label %153
45: ; preds = %41
store float 0.000000e+00, float* %28
store i32 1, i32* %22
br label %46
46: ; preds = %88, %45
%47 = load i32, i32* %22
%48 = load i32, i32* %13
%49 = icmp sle i32 %47, %48
br i1 %49, label %50, label %91
50: ; preds = %46
%51 = load i8*, i8** %12
%52 = load i32, i32* %21
%53 = load i32, i32* %22
%54 = add nsw i32 %52, %53
%55 = sub nsw i32 %54, 1
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %51, i64 %56
%58 = load i8, i8* %57
store i8 %58, i8* %25
%59 = load i8, i8* %25
%60 = sext i8 %59 to i32
%61 = icmp sgt i32 %60, 0
%62 = zext i1 %61 to i32
%63 = load i8, i8* %25
%64 = sext i8 %63 to i32
%65 = icmp slt i32 %64, 5
%66 = zext i1 %65 to i32
%67 = and i32 %62, %66
%68 = icmp ne i32 %67, 0
br i1 %68, label %69, label %82
69: ; preds = %50
%70 = load float**, float*** %11
%71 = load i8, i8* %25
%72 = sext i8 %71 to i64
%73 = getelementptr inbounds float*, float** %70, i64 %72
%74 = load float*, float** %73
%75 = load i32, i32* %22
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds float, float* %74, i64 %76
%78 = load float, float* %77
store float %78, float* %26
%79 = load float, float* %26
%80 = load float, float* %28
%81 = fadd float %80, %79
store float %81, float* %28
br label %87
82: ; preds = %50
%83 = load float, float* %28
%84 = fpext float %83 to double
%85 = fadd double %84, -7.600000e+00
%86 = fptrunc double %85 to float
store float %86, float* %28
br label %87
87: ; preds = %82, %69
br label %88
88: ; preds = %87
%89 = load i32, i32* %22
%90 = add nsw i32 %89, 1
store i32 %90, i32* %22
br label %46
91: ; preds = %46
%92 = load float, float* %28
%93 = load float, float* %15
%94 = fcmp oge float %92, %93
br i1 %94, label %95, label %149
95: ; preds = %91
%96 = load i32, i32* %27
%97 = add nsw i32 %96, 1
store i32 %97, i32* %27
%98 = load i32, i32* %14
%99 = load i32, i32* %21
%100 = sub nsw i32 %98, %99
%101 = load i32*, i32** %16
%102 = load i32, i32* %27
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i32, i32* %101, i64 %103
store i32 %100, i32* %104
%105 = load i32, i32* %30
%106 = trunc i32 %105 to i8
%107 = load i8*, i8** %17
%108 = load i32, i32* %27
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i8, i8* %107, i64 %109
store i8 %106, i8* %110
store i32 1, i32* %22
br label %111
111: ; preds = %128, %95
%112 = load i32, i32* %22
%113 = load i32, i32* %13
%114 = icmp sle i32 %112, %113
br i1 %114, label %115, label %131
115: ; preds = %111
%116 = load i8*, i8** %12
%117 = load i32, i32* %21
%118 = load i32, i32* %22
%119 = add nsw i32 %117, %118
%120 = sub nsw i32 %119, 1
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %116, i64 %121
%123 = load i8, i8* %122
%124 = load i8*, i8** %32
%125 = load i32, i32* %22
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i8, i8* %124, i64 %126
store i8 %123, i8* %127
br label %128
128: ; preds = %115
%129 = load i32, i32* %22
%130 = add nsw i32 %129, 1
store i32 %130, i32* %22
br label %111
131: ; preds = %111
%132 = load i8*, i8** %31
%133 = call i32 @sprintf(i8* %132, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%134 = load i8*, i8** %32
%135 = load i32, i32* %13
%136 = load i8*, i8** %31
%137 = call i32 @num2seq(i8* %134, i32 %135, i8* %136, i32 1)
%138 = load i32*, i32** %19
%139 = load i32, i32* %20
%140 = load i32*, i32** %16
%141 = load i32, i32* %27
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i32, i32* %140, i64 %142
%144 = load i32, i32* %143
%145 = load float, float* %28
%146 = load i8*, i8** %31
%147 = load i32, i32* %30
%148 = call i32 @fprintf(i32* %138, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i32 %139, i32 %144, float %145, i8* %146, i32 %147)
br label %149
149: ; preds = %131, %91
br label %150
150: ; preds = %149
%151 = load i32, i32* %21
%152 = add nsw i32 %151, 1
store i32 %152, i32* %21
br label %41
153: ; preds = %41
store i32 0, i32* %30
%154 = load i32, i32* %18
%155 = icmp eq i32 %154, 1
br i1 %155, label %156, label %275
156: ; preds = %153
%157 = load i32, i32* %14
%158 = call i8* @cvector(i32 1, i32 %157)
store i8* %158, i8** %29
%159 = load i8*, i8** %12
%160 = load i8*, i8** %29
%161 = load i32, i32* %14
%162 = call i32 @revcomp(i8* %159, i8* %160, i32 %161)
store i32 1, i32* %21
br label %163
163: ; preds = %268, %156
%164 = load i32, i32* %21
%165 = load i32, i32* %24
%166 = icmp sle i32 %164, %165
br i1 %166, label %167, label %271
167: ; preds = %163
store float 0.000000e+00, float* %28
store i32 1, i32* %22
br label %168
168: ; preds = %210, %167
%169 = load i32, i32* %22
%170 = load i32, i32* %13
%171 = icmp sle i32 %169, %170
br i1 %171, label %172, label %213
172: ; preds = %168
%173 = load i8*, i8** %29
%174 = load i32, i32* %21
%175 = load i32, i32* %22
%176 = add nsw i32 %174, %175
%177 = sub nsw i32 %176, 1
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds i8, i8* %173, i64 %178
%180 = load i8, i8* %179
store i8 %180, i8* %25
%181 = load i8, i8* %25
%182 = sext i8 %181 to i32
%183 = icmp sgt i32 %182, 0
%184 = zext i1 %183 to i32
%185 = load i8, i8* %25
%186 = sext i8 %185 to i32
%187 = icmp slt i32 %186, 5
%188 = zext i1 %187 to i32
%189 = and i32 %184, %188
%190 = icmp ne i32 %189, 0
br i1 %190, label %191, label %204
191: ; preds = %172
%192 = load float**, float*** %11
%193 = load i8, i8* %25
%194 = sext i8 %193 to i64
%195 = getelementptr inbounds float*, float** %192, i64 %194
%196 = load float*, float** %195
%197 = load i32, i32* %22
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float, float* %196, i64 %198
%200 = load float, float* %199
store float %200, float* %26
%201 = load float, float* %26
%202 = load float, float* %28
%203 = fadd float %202, %201
store float %203, float* %28
br label %209
204: ; preds = %172
%205 = load float, float* %28
%206 = fpext float %205 to double
%207 = fadd double %206, -7.600000e+00
%208 = fptrunc double %207 to float
store float %208, float* %28
br label %209
209: ; preds = %204, %191
br label %210
210: ; preds = %209
%211 = load i32, i32* %22
%212 = add nsw i32 %211, 1
store i32 %212, i32* %22
br label %168
213: ; preds = %168
%214 = load float, float* %28
%215 = load float, float* %15
%216 = fcmp oge float %214, %215
br i1 %216, label %217, label %267
217: ; preds = %213
%218 = load i32, i32* %27
%219 = add nsw i32 %218, 1
store i32 %219, i32* %27
%220 = load i32, i32* %21
%221 = load i32*, i32** %16
%222 = load i32, i32* %27
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i32, i32* %221, i64 %223
store i32 %220, i32* %224
%225 = load i8*, i8** %17
%226 = load i32, i32* %27
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds i8, i8* %225, i64 %227
store i8 0, i8* %228
store i32 1, i32* %22
br label %229
229: ; preds = %246, %217
%230 = load i32, i32* %22
%231 = load i32, i32* %13
%232 = icmp sle i32 %230, %231
br i1 %232, label %233, label %249
233: ; preds = %229
%234 = load i8*, i8** %29
%235 = load i32, i32* %21
%236 = load i32, i32* %22
%237 = add nsw i32 %235, %236
%238 = sub nsw i32 %237, 1
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds i8, i8* %234, i64 %239
%241 = load i8, i8* %240
%242 = load i8*, i8** %32
%243 = load i32, i32* %22
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds i8, i8* %242, i64 %244
store i8 %241, i8* %245
br label %246
246: ; preds = %233
%247 = load i32, i32* %22
%248 = add nsw i32 %247, 1
store i32 %248, i32* %22
br label %229
249: ; preds = %229
%250 = load i8*, i8** %31
%251 = call i32 @sprintf(i8* %250, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%252 = load i8*, i8** %32
%253 = load i32, i32* %13
%254 = load i8*, i8** %31
%255 = call i32 @num2seq(i8* %252, i32 %253, i8* %254, i32 1)
%256 = load i32*, i32** %19
%257 = load i32, i32* %20
%258 = load i32*, i32** %16
%259 = load i32, i32* %27
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds i32, i32* %258, i64 %260
%262 = load i32, i32* %261
%263 = load float, float* %28
%264 = load i8*, i8** %31
%265 = load i32, i32* %30
%266 = call i32 @fprintf(i32* %256, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i32 %257, i32 %262, float %263, i8* %264, i32 %265)
br label %267
267: ; preds = %249, %213
br label %268
268: ; preds = %267
%269 = load i32, i32* %21
%270 = add nsw i32 %269, 1
store i32 %270, i32* %21
br label %163
271: ; preds = %163
%272 = load i8*, i8** %29
%273 = load i32, i32* %14
%274 = call i32 @free_cvector(i8* %272, i32 1, i32 %273)
br label %275
275: ; preds = %271, %153
%276 = load i8*, i8** %32
%277 = load i32, i32* %13
%278 = call i32 @free_cvector(i8* %276, i32 1, i32 %277)
%279 = load i8*, i8** %31
%280 = load i32, i32* %13
%281 = sub nsw i32 %280, 1
%282 = call i32 @free_cvector(i8* %279, i32 0, i32 %281)
%283 = load i32, i32* %27
ret i32 %283
}

LLVM IR (-O2):
@.str.1 = [18 x i8] c"%d\09%d\09%.4f\09%s\09%d\0A\00"
define i32 @scan_motif3(float** nocapture %0, i8* %1, i32 %2, i32 %3, float %4, i32* nocapture %5, i8* nocapture writeonly %6, i32 %7, i32* nocapture %8, i32 %9) {
%11 = tail call i8* @cvector(i32 1, i32 %2)
%12 = add nsw i32 %2, -1
%13 = tail call i8* @cvector(i32 0, i32 %12)
%14 = icmp sgt i32 %3, %2
br i1 %14, label %15, label %230
15: ; preds = %10
%16 = icmp slt i32 %2, 1
%17 = add nsw i32 %2, 1
%18 = add i32 %3, 1
%19 = sub i32 %18, %2
%20 = zext i32 %19 to i64
%21 = zext i32 %17 to i64
%22 = zext i32 %17 to i64
%23 = fcmp ugt float %4, 0.000000e+00
%24 = add nsw i64 %21, -2
%25 = getelementptr i8, i8* %11, i64 1
%26 = getelementptr i8, i8* %11, i64 %21
%27 = add nsw i64 %21, -1
%28 = getelementptr i8, i8* %1, i64 %27
%29 = add nsw i64 %21, -1
%30 = add nsw i64 %21, -1
%31 = add nsw i64 %21, -33
%32 = lshr i64 %31, 5
%33 = add nuw nsw i64 %32, 1
%34 = icmp ult i64 %29, 8
%35 = trunc i64 %24 to i32
%36 = icmp ugt i64 %24, 4294967295
%37 = icmp ult i64 %29, 32
%38 = and i64 %29, -32
%39 = and i64 %33, 1
%40 = icmp ult i64 %31, 32
%41 = and i64 %33, 1152921504606846974
%42 = icmp eq i64 %39, 0
%43 = icmp eq i64 %29, %38
%44 = or i64 %38, 1
%45 = and i64 %29, 24
%46 = icmp eq i64 %45, 0
%47 = and i64 %30, -8
%48 = or i64 %47, 1
%49 = icmp eq i64 %30, %47
%50 = and i64 %21, 1
%51 = icmp eq i64 %50, 0
%52 = sub nsw i64 0, %21
br label %53
53: ; preds = %15, %225
%54 = phi i32 [ 0, %15 ], [ %229, %225 ]
%55 = phi i64 [ 1, %15 ], [ %227, %225 ]
%56 = phi i32 [ 0, %15 ], [ %226, %225 ]
%57 = add i32 %54, 1
%58 = sext i32 %57 to i64
%59 = getelementptr i8, i8* %1, i64 %58
%60 = getelementptr i8, i8* %28, i64 %58
%61 = add i32 %54, 1
br i1 %16, label %91, label %62
62: ; preds = %53
%63 = add nuw i64 %55, 4294967295
br label %64
64: ; preds = %62, %85
%65 = phi i64 [ 1, %62 ], [ %87, %85 ]
%66 = phi float [ 0.000000e+00, %62 ], [ %86, %85 ]
%67 = add i64 %63, %65
%68 = shl i64 %67, 32
%69 = ashr exact i64 %68, 32
%70 = getelementptr inbounds i8, i8* %1, i64 %69
%71 = load i8, i8* %70
%72 = add i8 %71, -1
%73 = icmp ult i8 %72, 4
br i1 %73, label %74, label %81
74: ; preds = %64
%75 = zext i8 %71 to i64
%76 = getelementptr inbounds float*, float** %0, i64 %75
%77 = load float*, float** %76
%78 = getelementptr inbounds float, float* %77, i64 %65
%79 = load float, float* %78
%80 = fadd float %66, %79
br label %85
81: ; preds = %64
%82 = fpext float %66 to double
%83 = fadd double %82, -7.600000e+00
%84 = fptrunc double %83 to float
br label %85
85: ; preds = %74, %81
%86 = phi float [ %80, %74 ], [ %84, %81 ]
%87 = add nuw nsw i64 %65, 1
%88 = icmp eq i64 %87, %21
br i1 %88, label %89, label %64
89: ; preds = %85
%90 = fcmp ult float %86, %4
br i1 %90, label %225, label %99
91: ; preds = %53
br i1 %23, label %225, label %92
92: ; preds = %91
%93 = add nsw i32 %56, 1
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %5, i64 %94
%96 = trunc i64 %55 to i32
%97 = sub i32 %3, %96
store i32 %97, i32* %95
%98 = getelementptr inbounds i8, i8* %6, i64 %94
store i8 1, i8* %98
br label %218
99: ; preds = %89
%100 = add nsw i32 %56, 1
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %5, i64 %101
%103 = trunc i64 %55 to i32
%104 = sub i32 %3, %103
store i32 %104, i32* %102
%105 = getelementptr inbounds i8, i8* %6, i64 %101
store i8 1, i8* %105
br i1 %16, label %218, label %106
106: ; preds = %99
%107 = add nuw i64 %55, 4294967295
br i1 %34, label %187, label %108
108: ; preds = %106
%109 = add i32 %61, %35
%110 = icmp slt i32 %109, %61
%111 = or i1 %110, %36
br i1 %111, label %187, label %112
112: ; preds = %108
%113 = icmp ult i8* %25, %60
%114 = icmp ult i8* %59, %26
%115 = and i1 %113, %114
br i1 %115, label %187, label %116
116: ; preds = %112
br i1 %37, label %171, label %117
117: ; preds = %116
br i1 %40, label %152, label %118
118: ; preds = %117, %118
%119 = phi i64 [ %149, %118 ], [ 0, %117 ]
%120 = phi i64 [ %150, %118 ], [ 0, %117 ]
%121 = or i64 %119, 1
%122 = add i64 %107, %121
%123 = shl i64 %122, 32
%124 = ashr exact i64 %123, 32
%125 = getelementptr inbounds i8, i8* %1, i64 %124
%126 = bitcast i8* %125 to <16 x i8>*
%127 = load <16 x i8>, <16 x i8>* %126
%128 = getelementptr inbounds i8, i8* %125, i64 16
%129 = bitcast i8* %128 to <16 x i8>*
%130 = load <16 x i8>, <16 x i8>* %129
%131 = getelementptr inbounds i8, i8* %11, i64 %121
%132 = bitcast i8* %131 to <16 x i8>*
store <16 x i8> %127, <16 x i8>* %132
%133 = getelementptr inbounds i8, i8* %131, i64 16
%134 = bitcast i8* %133 to <16 x i8>*
store <16 x i8> %130, <16 x i8>* %134
%135 = or i64 %119, 33
%136 = add i64 %107, %135
%137 = shl i64 %136, 32
%138 = ashr exact i64 %137, 32
%139 = getelementptr inbounds i8, i8* %1, i64 %138
%140 = bitcast i8* %139 to <16 x i8>*
%141 = load <16 x i8>, <16 x i8>* %140
%142 = getelementptr inbounds i8, i8* %139, i64 16
%143 = bitcast i8* %142 to <16 x i8>*
%144 = load <16 x i8>, <16 x i8>* %143
%145 = getelementptr inbounds i8, i8* %11, i64 %135
%146 = bitcast i8* %145 to <16 x i8>*
store <16 x i8> %141, <16 x i8>* %146
%147 = getelementptr inbounds i8, i8* %145, i64 16
%148 = bitcast i8* %147 to <16 x i8>*
store <16 x i8> %144, <16 x i8>* %148
%149 = add nuw i64 %119, 64
%150 = add i64 %120, 2
%151 = icmp eq i64 %150, %41
br i1 %151, label %152, label %118
152: ; preds = %118, %117
%153 = phi i64 [ 0, %117 ], [ %149, %118 ]
br i1 %42, label %169, label %154
154: ; preds = %152
%155 = or i64 %153, 1
%156 = add i64 %107, %155
%157 = shl i64 %156, 32
%158 = ashr exact i64 %157, 32
%159 = getelementptr inbounds i8, i8* %1, i64 %158
%160 = bitcast i8* %159 to <16 x i8>*
%161 = load <16 x i8>, <16 x i8>* %160
%162 = getelementptr inbounds i8, i8* %159, i64 16
%163 = bitcast i8* %162 to <16 x i8>*
%164 = load <16 x i8>, <16 x i8>* %163
%165 = getelementptr inbounds i8, i8* %11, i64 %155
%166 = bitcast i8* %165 to <16 x i8>*
store <16 x i8> %161, <16 x i8>* %166
%167 = getelementptr inbounds i8, i8* %165, i64 16
%168 = bitcast i8* %167 to <16 x i8>*
store <16 x i8> %164, <16 x i8>* %168
br label %169
169: ; preds = %152, %154
br i1 %43, label %218, label %170
170: ; preds = %169
br i1 %46, label %187, label %171
171: ; preds = %116, %170
%172 = phi i64 [ %38, %170 ], [ 0, %116 ]
br label %173
173: ; preds = %173, %171
%174 = phi i64 [ %172, %171 ], [ %184, %173 ]
%175 = or i64 %174, 1
%176 = add i64 %107, %175
%177 = shl i64 %176, 32
%178 = ashr exact i64 %177, 32
%179 = getelementptr inbounds i8, i8* %1, i64 %178
%180 = bitcast i8* %179 to <8 x i8>*
%181 = load <8 x i8>, <8 x i8>* %180
%182 = getelementptr inbounds i8, i8* %11, i64 %175
%183 = bitcast i8* %182 to <8 x i8>*
store <8 x i8> %181, <8 x i8>* %183
%184 = add nuw i64 %174, 8
%185 = icmp eq i64 %184, %47
br i1 %185, label %186, label %173
186: ; preds = %173
br i1 %49, label %218, label %187
187: ; preds = %112, %108, %106, %170, %186
%188 = phi i64 [ 1, %106 ], [ 1, %112 ], [ 1, %108 ], [ %44, %170 ], [ %48, %186 ]
%189 = xor i64 %188, -1
br i1 %51, label %190, label %198
190: ; preds = %187
%191 = add i64 %107, %188
%192 = shl i64 %191, 32
%193 = ashr exact i64 %192, 32
%194 = getelementptr inbounds i8, i8* %1, i64 %193
%195 = load i8, i8* %194
%196 = getelementptr inbounds i8, i8* %11, i64 %188
store i8 %195, i8* %196
%197 = add nuw nsw i64 %188, 1
br label %198
198: ; preds = %190, %187
%199 = phi i64 [ %188, %187 ], [ %197, %190 ]
%200 = icmp eq i64 %189, %52
br i1 %200, label %218, label %201
201: ; preds = %198, %201
%202 = phi i64 [ %216, %201 ], [ %199, %198 ]
%203 = add i64 %107, %202
%204 = shl i64 %203, 32
%205 = ashr exact i64 %204, 32
%206 = getelementptr inbounds i8, i8* %1, i64 %205
%207 = load i8, i8* %206
%208 = getelementptr inbounds i8, i8* %11, i64 %202
store i8 %207, i8* %208
%209 = add nuw nsw i64 %202, 1
%210 = add i64 %107, %209
%211 = shl i64 %210, 32
%212 = ashr exact i64 %211, 32
%213 = getelementptr inbounds i8, i8* %1, i64 %212
%214 = load i8, i8* %213
%215 = getelementptr inbounds i8, i8* %11, i64 %209
store i8 %214, i8* %215
%216 = add nuw nsw i64 %202, 2
%217 = icmp eq i64 %216, %22
br i1 %217, label %218, label %201
218: ; preds = %198, %201, %169, %186, %92, %99
%219 = phi i32* [ %95, %92 ], [ %102, %99 ], [ %102, %186 ], [ %102, %169 ], [ %102, %201 ], [ %102, %198 ]
%220 = phi i32 [ %93, %92 ], [ %100, %99 ], [ %100, %186 ], [ %100, %169 ], [ %100, %201 ], [ %100, %198 ]
%221 = phi float [ 0.000000e+00, %92 ], [ %86, %99 ], [ %86, %186 ], [ %86, %169 ], [ %86, %201 ], [ %86, %198 ]
store i8 0, i8* %13
%222 = tail call i32 @num2seq(i8* %11, i32 %2, i8* %13, i32 1)
%223 = load i32, i32* %219
%224 = tail call i32 @fprintf(i32* %8, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i32 %9, i32 %223, float %221, i8* %13, i32 1)
br label %225
225: ; preds = %91, %89, %218
%226 = phi i32 [ %220, %218 ], [ %56, %89 ], [ %56, %91 ]
%227 = add nuw nsw i64 %55, 1
%228 = icmp eq i64 %227, %20
%229 = add i32 %54, 1
br i1 %228, label %230, label %53
230: ; preds = %225, %10
%231 = phi i32 [ 0, %10 ], [ %226, %225 ]
%232 = icmp eq i32 %7, 1
br i1 %232, label %233, label %452
233: ; preds = %230
%234 = tail call i8* @cvector(i32 1, i32 %3)
%235 = tail call i32 @revcomp(i8* %1, i8* %234, i32 %3)
br i1 %14, label %236, label %449
236: ; preds = %233
%237 = icmp slt i32 %2, 1
%238 = add nsw i32 %2, 1
%239 = add i32 %3, 1
%240 = sub i32 %239, %2
%241 = zext i32 %240 to i64
%242 = zext i32 %238 to i64
%243 = zext i32 %238 to i64
%244 = fcmp ugt float %4, 0.000000e+00
%245 = add nsw i64 %242, -2
%246 = getelementptr i8, i8* %11, i64 1
%247 = getelementptr i8, i8* %11, i64 %242
%248 = add nsw i64 %242, -1
%249 = getelementptr i8, i8* %234, i64 %248
%250 = add nsw i64 %242, -1
%251 = add nsw i64 %242, -1
%252 = add nsw i64 %242, -33
%253 = lshr i64 %252, 5
%254 = add nuw nsw i64 %253, 1
%255 = icmp ult i64 %250, 8
%256 = trunc i64 %245 to i32
%257 = icmp ugt i64 %245, 4294967295
%258 = icmp ult i64 %250, 32
%259 = and i64 %250, -32
%260 = and i64 %254, 1
%261 = icmp ult i64 %252, 32
%262 = and i64 %254, 1152921504606846974
%263 = icmp eq i64 %260, 0
%264 = icmp eq i64 %250, %259
%265 = or i64 %259, 1
%266 = and i64 %250, 24
%267 = icmp eq i64 %266, 0
%268 = and i64 %251, -8
%269 = or i64 %268, 1
%270 = icmp eq i64 %251, %268
%271 = and i64 %242, 1
%272 = icmp eq i64 %271, 0
%273 = sub nsw i64 0, %242
br label %274
274: ; preds = %236, %444
%275 = phi i32 [ 0, %236 ], [ %448, %444 ]
%276 = phi i64 [ 1, %236 ], [ %446, %444 ]
%277 = phi i32 [ %231, %236 ], [ %445, %444 ]
%278 = add i32 %275, 1
%279 = sext i32 %278 to i64
%280 = getelementptr i8, i8* %234, i64 %279
%281 = getelementptr i8, i8* %249, i64 %279
%282 = add i32 %275, 1
br i1 %237, label %312, label %283
283: ; preds = %274
%284 = add nuw i64 %276, 4294967295
br label %285
285: ; preds = %283, %306
%286 = phi i64 [ 1, %283 ], [ %308, %306 ]
%287 = phi float [ 0.000000e+00, %283 ], [ %307, %306 ]
%288 = add i64 %284, %286
%289 = shl i64 %288, 32
%290 = ashr exact i64 %289, 32
%291 = getelementptr inbounds i8, i8* %234, i64 %290
%292 = load i8, i8* %291
%293 = add i8 %292, -1
%294 = icmp ult i8 %293, 4
br i1 %294, label %295, label %302
295: ; preds = %285
%296 = zext i8 %292 to i64
%297 = getelementptr inbounds float*, float** %0, i64 %296
%298 = load float*, float** %297
%299 = getelementptr inbounds float, float* %298, i64 %286
%300 = load float, float* %299
%301 = fadd float %287, %300
br label %306
302: ; preds = %285
%303 = fpext float %287 to double
%304 = fadd double %303, -7.600000e+00
%305 = fptrunc double %304 to float
br label %306
306: ; preds = %295, %302
%307 = phi float [ %301, %295 ], [ %305, %302 ]
%308 = add nuw nsw i64 %286, 1
%309 = icmp eq i64 %308, %242
br i1 %309, label %310, label %285
310: ; preds = %306
%311 = fcmp ult float %307, %4
br i1 %311, label %444, label %319
312: ; preds = %274
br i1 %244, label %444, label %313
313: ; preds = %312
%314 = add nsw i32 %277, 1
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds i32, i32* %5, i64 %315
%317 = trunc i64 %276 to i32
store i32 %317, i32* %316
%318 = getelementptr inbounds i8, i8* %6, i64 %315
store i8 0, i8* %318
br label %437
319: ; preds = %310
%320 = add nsw i32 %277, 1
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds i32, i32* %5, i64 %321
%323 = trunc i64 %276 to i32
store i32 %323, i32* %322
%324 = getelementptr inbounds i8, i8* %6, i64 %321
store i8 0, i8* %324
br i1 %237, label %437, label %325
325: ; preds = %319
%326 = add nuw i64 %276, 4294967295
br i1 %255, label %406, label %327
327: ; preds = %325
%328 = add i32 %282, %256
%329 = icmp slt i32 %328, %282
%330 = or i1 %329, %257
br i1 %330, label %406, label %331
331: ; preds = %327
%332 = icmp ult i8* %246, %281
%333 = icmp ult i8* %280, %247
%334 = and i1 %332, %333
br i1 %334, label %406, label %335
335: ; preds = %331
br i1 %258, label %390, label %336
336: ; preds = %335
br i1 %261, label %371, label %337
337: ; preds = %336, %337
%338 = phi i64 [ %368, %337 ], [ 0, %336 ]
%339 = phi i64 [ %369, %337 ], [ 0, %336 ]
%340 = or i64 %338, 1
%341 = add i64 %326, %340
%342 = shl i64 %341, 32
%343 = ashr exact i64 %342, 32
%344 = getelementptr inbounds i8, i8* %234, i64 %343
%345 = bitcast i8* %344 to <16 x i8>*
%346 = load <16 x i8>, <16 x i8>* %345
%347 = getelementptr inbounds i8, i8* %344, i64 16
%348 = bitcast i8* %347 to <16 x i8>*
%349 = load <16 x i8>, <16 x i8>* %348
%350 = getelementptr inbounds i8, i8* %11, i64 %340
%351 = bitcast i8* %350 to <16 x i8>*
store <16 x i8> %346, <16 x i8>* %351
%352 = getelementptr inbounds i8, i8* %350, i64 16
%353 = bitcast i8* %352 to <16 x i8>*
store <16 x i8> %349, <16 x i8>* %353
%354 = or i64 %338, 33
%355 = add i64 %326, %354
%356 = shl i64 %355, 32
%357 = ashr exact i64 %356, 32
%358 = getelementptr inbounds i8, i8* %234, i64 %357
%359 = bitcast i8* %358 to <16 x i8>*
%360 = load <16 x i8>, <16 x i8>* %359
%361 = getelementptr inbounds i8, i8* %358, i64 16
%362 = bitcast i8* %361 to <16 x i8>*
%363 = load <16 x i8>, <16 x i8>* %362
%364 = getelementptr inbounds i8, i8* %11, i64 %354
%365 = bitcast i8* %364 to <16 x i8>*
store <16 x i8> %360, <16 x i8>* %365
%366 = getelementptr inbounds i8, i8* %364, i64 16
%367 = bitcast i8* %366 to <16 x i8>*
store <16 x i8> %363, <16 x i8>* %367
%368 = add nuw i64 %338, 64
%369 = add i64 %339, 2
%370 = icmp eq i64 %369, %262
br i1 %370, label %371, label %337
371: ; preds = %337, %336
%372 = phi i64 [ 0, %336 ], [ %368, %337 ]
br i1 %263, label %388, label %373
373: ; preds = %371
%374 = or i64 %372, 1
%375 = add i64 %326, %374
%376 = shl i64 %375, 32
%377 = ashr exact i64 %376, 32
%378 = getelementptr inbounds i8, i8* %234, i64 %377
%379 = bitcast i8* %378 to <16 x i8>*
%380 = load <16 x i8>, <16 x i8>* %379
%381 = getelementptr inbounds i8, i8* %378, i64 16
%382 = bitcast i8* %381 to <16 x i8>*
%383 = load <16 x i8>, <16 x i8>* %382
%384 = getelementptr inbounds i8, i8* %11, i64 %374
%385 = bitcast i8* %384 to <16 x i8>*
store <16 x i8> %380, <16 x i8>* %385
%386 = getelementptr inbounds i8, i8* %384, i64 16
%387 = bitcast i8* %386 to <16 x i8>*
store <16 x i8> %383, <16 x i8>* %387
br label %388
388: ; preds = %371, %373
br i1 %264, label %437, label %389
389: ; preds = %388
br i1 %267, label %406, label %390
390: ; preds = %335, %389
%391 = phi i64 [ %259, %389 ], [ 0, %335 ]
br label %392
392: ; preds = %392, %390
%393 = phi i64 [ %391, %390 ], [ %403, %392 ]
%394 = or i64 %393, 1
%395 = add i64 %326, %394
%396 = shl i64 %395, 32
%397 = ashr exact i64 %396, 32
%398 = getelementptr inbounds i8, i8* %234, i64 %397
%399 = bitcast i8* %398 to <8 x i8>*
%400 = load <8 x i8>, <8 x i8>* %399
%401 = getelementptr inbounds i8, i8* %11, i64 %394
%402 = bitcast i8* %401 to <8 x i8>*
store <8 x i8> %400, <8 x i8>* %402
%403 = add nuw i64 %393, 8
%404 = icmp eq i64 %403, %268
br i1 %404, label %405, label %392
405: ; preds = %392
br i1 %270, label %437, label %406
406: ; preds = %331, %327, %325, %389, %405
%407 = phi i64 [ 1, %325 ], [ 1, %331 ], [ 1, %327 ], [ %265, %389 ], [ %269, %405 ]
%408 = xor i64 %407, -1
br i1 %272, label %409, label %417
409: ; preds = %406
%410 = add i64 %326, %407
%411 = shl i64 %410, 32
%412 = ashr exact i64 %411, 32
%413 = getelementptr inbounds i8, i8* %234, i64 %412
%414 = load i8, i8* %413
%415 = getelementptr inbounds i8, i8* %11, i64 %407
store i8 %414, i8* %415
%416 = add nuw nsw i64 %407, 1
br label %417
417: ; preds = %409, %406
%418 = phi i64 [ %407, %406 ], [ %416, %409 ]
%419 = icmp eq i64 %408, %273
br i1 %419, label %437, label %420
420: ; preds = %417, %420
%421 = phi i64 [ %435, %420 ], [ %418, %417 ]
%422 = add i64 %326, %421
%423 = shl i64 %422, 32
%424 = ashr exact i64 %423, 32
%425 = getelementptr inbounds i8, i8* %234, i64 %424
%426 = load i8, i8* %425
%427 = getelementptr inbounds i8, i8* %11, i64 %421
store i8 %426, i8* %427
%428 = add nuw nsw i64 %421, 1
%429 = add i64 %326, %428
%430 = shl i64 %429, 32
%431 = ashr exact i64 %430, 32
%432 = getelementptr inbounds i8, i8* %234, i64 %431
%433 = load i8, i8* %432
%434 = getelementptr inbounds i8, i8* %11, i64 %428
store i8 %433, i8* %434
%435 = add nuw nsw i64 %421, 2
%436 = icmp eq i64 %435, %243
br i1 %436, label %437, label %420
437: ; preds = %417, %420, %388, %405, %313, %319
%438 = phi i32* [ %316, %313 ], [ %322, %319 ], [ %322, %405 ], [ %322, %388 ], [ %322, %420 ], [ %322, %417 ]
%439 = phi i32 [ %314, %313 ], [ %320, %319 ], [ %320, %405 ], [ %320, %388 ], [ %320, %420 ], [ %320, %417 ]
%440 = phi float [ 0.000000e+00, %313 ], [ %307, %319 ], [ %307, %405 ], [ %307, %388 ], [ %307, %420 ], [ %307, %417 ]
store i8 0, i8* %13
%441 = tail call i32 @num2seq(i8* %11, i32 %2, i8* %13, i32 1)
%442 = load i32, i32* %438
%443 = tail call i32 @fprintf(i32* %8, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i32 %9, i32 %442, float %440, i8* %13, i32 0)
br label %444
444: ; preds = %312, %310, %437
%445 = phi i32 [ %439, %437 ], [ %277, %310 ], [ %277, %312 ]
%446 = add nuw nsw i64 %276, 1
%447 = icmp eq i64 %446, %241
%448 = add i32 %275, 1
br i1 %447, label %449, label %274
449: ; preds = %444, %233
%450 = phi i32 [ %231, %233 ], [ %445, %444 ]
%451 = tail call i32 @free_cvector(i8* %234, i32 1, i32 %3)
br label %452
452: ; preds = %449, %230
%453 = phi i32 [ %450, %449 ], [ %231, %230 ]
%454 = tail call i32 @free_cvector(i8* %11, i32 1, i32 %2)
%455 = tail call i32 @free_cvector(i8* %13, i32 0, i32 %12)
ret i32 %453
}