#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_motif5(float **weight_matrix, float *mean_weight_matrix,
                char *sequence, char *revcomp_seq, int motif_length,
                int seq_length, float threshold, int *pos, char *strand, int rc,
                int min_dist, FILE *log_file, int seq_nr) {
  int i, j, k;
  int i_stop;
  char c;
  float p;
  int n;
  float current_score;
  int curr_strand;
  char *word;
  char *numword;
  int previous_position;
  i_stop = seq_length - motif_length;
  n = 0;
  if (seq_nr > 0) {
    numword = cvector(1, motif_length);
    word = cvector(0, motif_length - 1);
  }
  previous_position = -motif_length;
  curr_strand = 1;
  for (i = 1; i <= i_stop; i++) {
    if ((i - previous_position) > min_dist) {
      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 += mean_weight_matrix[j];
        }
      }
      if (current_score >= threshold) {
        previous_position = i;
        n++;
        pos[n] = seq_length - i;
        strand[n] = curr_strand;
        if (seq_nr > 0) {
          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;
  previous_position = -motif_length;
  if (rc == 1) {
    revcomp(sequence, revcomp_seq, seq_length);
    for (i = 1; i <= i_stop; i++) {
      if ((i - previous_position) > min_dist) {
        current_score = 0.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 += mean_weight_matrix[j];
          }
        }
        if (current_score >= threshold) {
          previous_position = i;
          n++;
          pos[n] = i;
          strand[n] = 0;
          if (seq_nr > 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);
          }
        }
      }
    }
  }
  if (seq_nr > 0) {
    free_cvector(numword, 1, motif_length);
    free_cvector(word, 0, motif_length - 1);
  }
  return n;
}


x86 assembly (clang, -O0):
<scan_motif5>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x48(%rbp)
cmpl   $0x0,0x38(%rbp)
jle    11d6 <scan_motif5+0x76>
mov    -0x24(%rbp),%esi
mov    $0x1,%edi
call   1030 <cvector@plt>
mov    %rax,-0x60(%rbp)
mov    -0x24(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1030 <cvector@plt>
mov    %rax,-0x58(%rbp)
xor    %eax,%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x1,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     13b0 <scan_motif5+0x250>
mov    -0x30(%rbp),%eax
sub    -0x64(%rbp),%eax
cmp    0x28(%rbp),%eax
jle    139d <scan_motif5+0x23d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     12bb <scan_motif5+0x15b>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x3d(%rbp)
movsbl -0x3d(%rbp),%eax
cmp    $0x0,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x3d(%rbp),%ecx
cmp    $0x5,%ecx
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1291 <scan_motif5+0x131>
mov    -0x8(%rbp),%rax
movsbq -0x3d(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    12a8 <scan_motif5+0x148>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    12ad <scan_motif5+0x14d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1216 <scan_motif5+0xb6>
movss  -0x4c(%rbp),%xmm0
ucomiss -0x2c(%rbp),%xmm0
jb     1398 <scan_motif5+0x238>
mov    -0x30(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%edx
sub    -0x30(%rbp),%edx
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
mov    %al,%dl
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
cmpl   $0x0,0x38(%rbp)
jle    1393 <scan_motif5+0x233>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1343 <scan_motif5+0x1e3>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    130b <scan_motif5+0x1ab>
mov    -0x58(%rbp),%rdi
lea    0xcc3(%rip),%rsi
call   1070 <sprintf@plt>
mov    -0x60(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x58(%rbp),%rdx
mov    $0x1,%ecx
call   1050 <num2seq@plt>
mov    0x30(%rbp),%rdi
mov    0x38(%rbp),%edx
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movss  -0x4c(%rbp),%xmm0
mov    -0x58(%rbp),%r8
mov    -0x50(%rbp),%r9d
lea    0xc72(%rip),%rsi
call   1040 <fprintf@plt>
jmp    1398 <scan_motif5+0x238>
jmp    139d <scan_motif5+0x23d>
jmp    13a2 <scan_motif5+0x242>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ec <scan_motif5+0x8c>
movl   $0x0,-0x50(%rbp)
xor    %eax,%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x1,0x20(%rbp)
jne    15a2 <scan_motif5+0x442>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%edx
call   1080 <revcomp@plt>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     159d <scan_motif5+0x43d>
mov    -0x30(%rbp),%eax
sub    -0x64(%rbp),%eax
cmp    0x28(%rbp),%eax
jle    158a <scan_motif5+0x42a>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     14af <scan_motif5+0x34f>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x3d(%rbp)
movsbl -0x3d(%rbp),%eax
cmp    $0x0,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x3d(%rbp),%ecx
cmp    $0x5,%ecx
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1485 <scan_motif5+0x325>
mov    -0x8(%rbp),%rax
movsbq -0x3d(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    149c <scan_motif5+0x33c>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    14a1 <scan_motif5+0x341>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    140a <scan_motif5+0x2aa>
movss  -0x4c(%rbp),%xmm0
ucomiss -0x2c(%rbp),%xmm0
jb     1585 <scan_motif5+0x425>
mov    -0x30(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%edx
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
cmpl   $0x0,0x38(%rbp)
jle    1580 <scan_motif5+0x420>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1530 <scan_motif5+0x3d0>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14f8 <scan_motif5+0x398>
mov    -0x58(%rbp),%rdi
lea    0xad6(%rip),%rsi
call   1070 <sprintf@plt>
mov    -0x60(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x58(%rbp),%rdx
mov    $0x1,%ecx
call   1050 <num2seq@plt>
mov    0x30(%rbp),%rdi
mov    0x38(%rbp),%edx
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movss  -0x4c(%rbp),%xmm0
mov    -0x58(%rbp),%r8
mov    -0x50(%rbp),%r9d
lea    0xa85(%rip),%rsi
call   1040 <fprintf@plt>
jmp    1585 <scan_motif5+0x425>
jmp    158a <scan_motif5+0x42a>
jmp    158f <scan_motif5+0x42f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13e0 <scan_motif5+0x280>
jmp    15a2 <scan_motif5+0x442>
cmpl   $0x0,0x38(%rbp)
jle    15ce <scan_motif5+0x46e>
mov    -0x60(%rbp),%rdi
mov    -0x24(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_cvector@plt>
mov    -0x58(%rbp),%rdi
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1060 <free_cvector@plt>
mov    -0x48(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scan_motif5>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
movss  %xmm0,0x20(%rsp)
mov    %r8,0x10(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rdx,%r12
mov    %rsi,%r14
mov    %rdi,0x50(%rsp)
cmpl   $0x0,0x178(%rsp)
mov    %r9,0x60(%rsp)
jle    11bd <scan_motif5+0x6d>
mov    $0x1,%edi
mov    0x10(%rsp),%rsi
call   1030 <cvector@plt>
mov    %rax,0x28(%rsp)
mov    0x10(%rsp),%rax
lea    -0x1(%rax),%esi
xor    %edi,%edi
call   1030 <cvector@plt>
mov    0x60(%rsp),%r9
mov    %rax,0xb8(%rsp)
jmp    11bd <scan_motif5+0x6d>
mov    %r9d,%ecx
sub    0x10(%rsp),%ecx
jle    17b8 <scan_motif5+0x668>
mov    0x168(%rsp),%r15d
mov    0x10(%rsp),%rax
mov    %eax,%r8d
neg    %r8d
add    $0x1,%eax
add    $0x1,%ecx
mov    %rcx,0x68(%rsp)
lea    -0x2(%rax),%rcx
lea    -0x1(%rax),%rsi
lea    -0x21(%rax),%rdx
mov    %rdx,0xc0(%rsp)
mov    %rdx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %rsi,%r13
and    $0xffffffffffffffe0,%r13
mov    %rdi,%rdx
mov    %rdi,0x90(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x108(%rsp)
mov    %rsi,%rbx
and    $0xfffffffffffffff8,%rbx
mov    %rax,%rdx
neg    %rdx
mov    %rdx,0xe0(%rsp)
mov    %rsi,%rdx
mov    %rsi,0x8(%rsp)
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    %rsi,0xe8(%rsp)
mov    %rcx,%rdx
mov    %rcx,0x88(%rsp)
shr    $0x20,%rcx
mov    %rcx,0xd8(%rsp)
movabs $0xffffffffffffffe,%rcx
ff ff 0f
mov    %rcx,0x98(%rsp)
movabs $0x2100000000,%rcx
movabs $0x200000000,%r10
movabs $0x100000000,%rbp
mov    0x28(%rsp),%rdi
lea    0x1(%rdi),%rdx
mov    %rdx,0xd0(%rsp)
lea    (%rdi,%rax,1),%rdx
mov    %rdx,0xc8(%rsp)
mov    %rax,0xb0(%rsp)
lea    -0x1(%r12,%rax,1),%rax
mov    %rax,0xa0(%rsp)
mov    %r13,0x78(%rsp)
lea    0x1(%r13),%rax
mov    %rax,0x100(%rsp)
mov    %rbx,0xa8(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x110(%rsp)
mov    0x68(%rsp),%rbx
mov    %r15d,%edx
lea    0x1(%rbp),%rsi
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    %rsi,%rax
mov    $0x1,%r15d
mov    %rbp,%r11
mov    %r10,0x38(%rsp)
mov    %rbp,%r13
mov    %r8d,0x58(%rsp)
mov    0x70(%rsp),%rsi
movss  0x20(%rsp),%xmm0
jmp    1364 <scan_motif5+0x214>
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%r11
mov    0x18(%rsp),%rcx
add    $0x1,%r15
add    $0x1,%r11
movabs $0x100000000,%rbp
add    %rbp,%r13
add    %rbp,0x38(%rsp)
add    %rbp,%rcx
add    $0x1,%rax
cmp    %rbx,%r15
je     17e2 <scan_motif5+0x692>
mov    %rcx,0x18(%rsp)
mov    %r15d,%ecx
sub    %r8d,%ecx
cmp    %edx,%ecx
jle    1335 <scan_motif5+0x1e5>
mov    %r15d,%ebp
mov    %r15d,0x24(%rsp)
mov    %r11,0x48(%rsp)
cmpl   $0x0,0x10(%rsp)
jle    1427 <scan_motif5+0x2d7>
mov    %rax,%r11
cmpq   $0x0,0x88(%rsp)
je     142c <scan_motif5+0x2dc>
xorps  %xmm1,%xmm1
mov    $0x1,%ecx
mov    0x38(%rsp),%rax
mov    %r13,%rsi
jmp    13e5 <scan_motif5+0x295>
nop
addss  (%r10,%rcx,4),%xmm1
addss  0x4(%rbx,%rcx,4),%xmm1
movabs $0x200000000,%r10
add    %r10,%rsi
add    %r10,%rax
mov    0xe8(%rsp),%rdx
add    %rcx,%rdx
add    $0x2,%rdx
add    $0x2,%rcx
cmp    $0x1,%rdx
je     1434 <scan_motif5+0x2e4>
mov    %rsi,%rdx
sar    $0x20,%rdx
movzbl (%r12,%rdx,1),%ebp
lea    -0x1(%rbp),%ebx
mov    %r14,%r10
cmp    $0x3,%bl
ja     1405 <scan_motif5+0x2b5>
mov    0x50(%rsp),%rdx
mov    (%rdx,%rbp,8),%r10
mov    %rax,%rdx
sar    $0x20,%rdx
movzbl (%r12,%rdx,1),%ebp
lea    -0x1(%rbp),%edx
mov    %r14,%rbx
cmp    $0x3,%dl
ja     13b0 <scan_motif5+0x260>
mov    0x50(%rsp),%rdx
mov    (%rdx,%rbp,8),%rbx
jmp    13b0 <scan_motif5+0x260>
xorps  %xmm1,%xmm1
jmp    148c <scan_motif5+0x33c>
xorps  %xmm1,%xmm1
mov    $0x1,%ecx
testb  $0x1,0x8(%rsp)
mov    0x70(%rsp),%rsi
mov    0x168(%rsp),%edx
mov    0x68(%rsp),%rbx
mov    %r11,%rax
je     148c <scan_motif5+0x33c>
movabs $0x100000000,%rax
add    %r15,%rax
add    $0xffffffffffffffff,%rax
add    %ecx,%eax
cltq
movzbl (%r12,%rax,1),%edx
lea    -0x1(%rdx),%eax
mov    %r14,%rbp
cmp    $0x3,%al
ja     147c <scan_motif5+0x32c>
mov    0x50(%rsp),%rax
mov    (%rax,%rdx,8),%rbp
addss  0x0(%rbp,%rcx,4),%xmm1
mov    0x168(%rsp),%edx
mov    %r11,%rax
ucomiss %xmm0,%xmm1
jb     1330 <scan_motif5+0x1e0>
mov    %rax,0x40(%rsp)
movslq 0x30(%rsp),%rbp
lea    0x1(%rbp),%rax
mov    %rax,0x30(%rsp)
mov    %r9d,%eax
sub    %r15d,%eax
mov    0x150(%rsp),%rcx
mov    %eax,0x4(%rcx,%rbp,4)
mov    0x158(%rsp),%rax
movb   $0x1,0x1(%rax,%rbp,1)
cmpl   $0x0,0x178(%rsp)
mov    0x48(%rsp),%r11
jle    17a4 <scan_motif5+0x654>
movss  %xmm1,0x80(%rsp)
cmpl   $0x0,0x10(%rsp)
mov    0xb0(%rsp),%r8
mov    0xa8(%rsp),%rax
jle    171e <scan_motif5+0x5ce>
movabs $0x100000000,%rcx
lea    (%rcx,%r15,1),%r9
add    $0xffffffffffffffff,%r9
mov    $0x1,%ecx
cmpq   $0x8,0x8(%rsp)
jb     16ab <scan_motif5+0x55b>
lea    0x1(%r11),%edx
mov    0x88(%rsp),%rsi
add    %edx,%esi
cmp    %edx,%esi
jl     16ab <scan_motif5+0x55b>
cmpq   $0x0,0xd8(%rsp)
jne    16ab <scan_motif5+0x55b>
movslq %edx,%rdx
mov    0xa0(%rsp),%rsi
add    %rdx,%rsi
cmp    %rsi,0xd0(%rsp)
jae    156f <scan_motif5+0x41f>
add    %r12,%rdx
cmp    0xc8(%rsp),%rdx
jb     16ab <scan_motif5+0x55b>
cmpq   $0x20,0x8(%rsp)
jae    157e <scan_motif5+0x42e>
xor    %edx,%edx
jmp    1665 <scan_motif5+0x515>
mov    %r9,0xf0(%rsp)
mov    %rbp,0xf8(%rsp)
cmpq   $0x20,0xc0(%rsp)
jae    159d <scan_motif5+0x44d>
xor    %ecx,%ecx
jmp    1608 <scan_motif5+0x4b8>
mov    0x108(%rsp),%rdx
mov    %r13,%rbp
mov    0x18(%rsp),%rbx
xor    %ecx,%ecx
movabs $0x4000000000,%r9
nopl   0x0(%rax)
mov    %rbp,%rsi
sar    $0x20,%rsi
movups (%r12,%rsi,1),%xmm0
movups 0x10(%r12,%rsi,1),%xmm1
movups %xmm0,0x1(%rdi,%rcx,1)
movups %xmm1,0x11(%rdi,%rcx,1)
mov    %rbx,%rsi
sar    $0x20,%rsi
movups (%r12,%rsi,1),%xmm0
movups 0x10(%r12,%rsi,1),%xmm1
movups %xmm0,0x21(%rdi,%rcx,1)
movups %xmm1,0x31(%rdi,%rcx,1)
add    $0x40,%rcx
add    %r9,%rbx
add    %r9,%rbp
add    $0xfffffffffffffffe,%rdx
jne    15c0 <scan_motif5+0x470>
testb  $0x1,0x90(%rsp)
01
mov    0xf0(%rsp),%r9
je     1639 <scan_motif5+0x4e9>
or     $0x1,%rcx
lea    (%rcx,%r9,1),%edx
movslq %edx,%rdx
movups (%r12,%rdx,1),%xmm0
movups 0x10(%r12,%rdx,1),%xmm1
movups %xmm0,(%rdi,%rcx,1)
movups %xmm1,0x10(%rdi,%rcx,1)
mov    0x78(%rsp),%rcx
cmp    %rcx,0x8(%rsp)
mov    0xf8(%rsp),%rbp
je     171e <scan_motif5+0x5ce>
mov    0x78(%rsp),%rdx
mov    0x100(%rsp),%rcx
testb  $0x18,0x8(%rsp)
je     16ab <scan_motif5+0x55b>
mov    0x40(%rsp),%rcx
add    %edx,%ecx
shl    $0x20,%rcx
movabs $0x800000000,%rbx
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rsi
sar    $0x20,%rsi
mov    (%r12,%rsi,1),%rsi
mov    %rsi,0x1(%rdi,%rdx,1)
add    $0x8,%rdx
add    %rbx,%rcx
cmp    %rdx,%rax
jne    1680 <scan_motif5+0x530>
mov    0x110(%rsp),%rcx
cmp    %rax,0x8(%rsp)
je     171e <scan_motif5+0x5ce>
mov    %rcx,%rdx
test   $0x1,%r8b
jne    16c5 <scan_motif5+0x575>
add    %ecx,%r9d
movslq %r9d,%rax
mov    (%r12,%rax,1),%al
mov    %al,(%rdi,%rcx,1)
lea    0x1(%rcx),%rdx
not    %rcx
cmp    0xe0(%rsp),%rcx
je     171e <scan_motif5+0x5ce>
lea    (%rdx,%r11,1),%eax
shl    $0x20,%rax
mov    0x40(%rsp),%rcx
add    %edx,%ecx
shl    $0x20,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,%rsi
sar    $0x20,%rsi
movzbl (%r12,%rsi,1),%ebx
mov    %bl,(%rdi,%rdx,1)
mov    %rcx,%rsi
sar    $0x20,%rsi
movzbl (%r12,%rsi,1),%ebx
mov    %bl,0x1(%rdi,%rdx,1)
add    $0x2,%rdx
add    %r10,%rax
add    %r10,%rcx
cmp    %rdx,%r8
jne    16f0 <scan_motif5+0x5a0>
mov    0xb8(%rsp),%rbx
movb   $0x0,(%rbx)
mov    0x10(%rsp),%rsi
mov    %rbx,%rdx
mov    $0x1,%ecx
call   1050 <num2seq@plt>
mov    0x150(%rsp),%rax
mov    0x4(%rax,%rbp,4),%ecx
mov    0x170(%rsp),%rdi
lea    0x8aa(%rip),%rsi
mov    0x178(%rsp),%edx
movss  0x80(%rsp),%xmm0
mov    %rbx,%r8
mov    $0x1,%r9d
call   1040 <fprintf@plt>
mov    0x48(%rsp),%r11
movabs $0x200000000,%r10
mov    0x60(%rsp),%r9
mov    0x28(%rsp),%rdi
mov    0x70(%rsp),%rsi
movss  0x20(%rsp),%xmm0
mov    0x168(%rsp),%edx
mov    0x68(%rsp),%rbx
mov    0x40(%rsp),%rax
mov    0x18(%rsp),%rcx
mov    0x24(%rsp),%r8d
jmp    133a <scan_motif5+0x1ea>
xor    %eax,%eax
cmpl   $0x1,0x160(%rsp)
01
jne    1d39 <scan_motif5+0xbe9>
mov    %rax,0x30(%rsp)
mov    %r12,%rdi
mov    0x70(%rsp),%rsi
mov    %r9d,%edx
call   1070 <revcomp@plt>
jmp    1d28 <scan_motif5+0xbd8>
cmpl   $0x1,0x160(%rsp)
01
jne    1d43 <scan_motif5+0xbf3>
mov    %r12,%rdi
mov    %r9d,%edx
mov    %rsi,%rbx
call   1070 <revcomp@plt>
mov    0x60(%rsp),%r9
sub    0x10(%rsp),%r9d
jle    1d28 <scan_motif5+0xbd8>
add    $0x1,%r9d
mov    0xb0(%rsp),%rax
add    %rbx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x68(%rsp)
mov    0x8(%rsp),%rcx
and    $0xffffffffffffffe0,%rcx
mov    0x98(%rsp),%rax
and    0x90(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    %rcx,0x80(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0x78(%rsp)
mov    0xa8(%rsp),%rax
add    $0x1,%rax
mov    %rax,0xa0(%rsp)
movabs $0x100000000,%r15
lea    0x1(%r15),%rsi
mov    $0x1,%r12d
mov    %r15,%r11
movabs $0x200000000,%r13
mov    0x28(%rsp),%rdi
mov    %rbx,%r10
movss  0x20(%rsp),%xmm0
movabs $0x2100000000,%rcx
mov    0x58(%rsp),%edx
mov    0x168(%rsp),%ebx
mov    %r9,0x60(%rsp)
jmp    18ec <scan_motif5+0x79c>
nopw   0x0(%rax,%rax,1)
mov    %edx,%ebp
add    $0x1,%r12
add    $0x1,%r11
movabs $0x100000000,%rax
add    %rax,%r15
add    %rax,%r13
add    %rax,%rcx
add    $0x1,%rsi
mov    %ebp,%edx
cmp    %r9,%r12
je     1d43 <scan_motif5+0xbf3>
mov    %r12d,%eax
sub    %edx,%eax
cmp    %ebx,%eax
jle    18c0 <scan_motif5+0x770>
mov    %r12d,%ebp
cmpl   $0x0,0x10(%rsp)
mov    %rcx,0x38(%rsp)
mov    %edx,0x58(%rsp)
mov    %rsi,0x18(%rsp)
mov    %r12d,0x48(%rsp)
jle    19ba <scan_motif5+0x86a>
cmpq   $0x0,0x88(%rsp)
je     19bf <scan_motif5+0x86f>
xorps  %xmm1,%xmm1
mov    $0x1,%r8d
mov    %r13,%rax
mov    %r15,%rdx
jmp    1977 <scan_motif5+0x827>
cs nopw 0x0(%rax,%rax,1)
addss  (%rsi,%r8,4),%xmm1
addss  0x4(%rbp,%r8,4),%xmm1
movabs $0x200000000,%rcx
add    %rcx,%rdx
add    %rcx,%rax
mov    0xe8(%rsp),%rcx
lea    (%rcx,%r8,1),%rsi
add    $0x2,%rsi
add    $0x2,%r8
cmp    $0x1,%rsi
je     19c8 <scan_motif5+0x878>
mov    %rdx,%rsi
sar    $0x20,%rsi
movzbl (%r10,%rsi,1),%ecx
lea    -0x1(%rcx),%ebp
mov    %r14,%rsi
cmp    $0x3,%bpl
ja     1998 <scan_motif5+0x848>
mov    0x50(%rsp),%rsi
mov    (%rsi,%rcx,8),%rsi
mov    %rax,%rcx
sar    $0x20,%rcx
movzbl (%r10,%rcx,1),%ecx
lea    -0x1(%rcx),%ebx
mov    %r14,%rbp
cmp    $0x3,%bl
ja     1940 <scan_motif5+0x7f0>
mov    0x50(%rsp),%rbx
mov    (%rbx,%rcx,8),%rbp
jmp    1940 <scan_motif5+0x7f0>
xorps  %xmm1,%xmm1
jmp    1a12 <scan_motif5+0x8c2>
xorps  %xmm1,%xmm1
mov    $0x1,%r8d
testb  $0x1,0x8(%rsp)
mov    0x168(%rsp),%ebx
mov    0x48(%rsp),%ebp
je     1a12 <scan_motif5+0x8c2>
movabs $0x100000000,%rax
lea    (%rax,%r12,1),%rcx
add    $0xffffffffffffffff,%rcx
add    %r8d,%ecx
movslq %ecx,%rcx
movzbl (%r10,%rcx,1),%ecx
lea    -0x1(%rcx),%esi
mov    %r14,%rdx
cmp    $0x3,%sil
ja     1a0c <scan_motif5+0x8bc>
mov    0x50(%rsp),%rax
mov    (%rax,%rcx,8),%rdx
addss  (%rdx,%r8,4),%xmm1
ucomiss %xmm0,%xmm1
jae    1a20 <scan_motif5+0x8d0>
mov    0x58(%rsp),%ebp
jmp    1b00 <scan_motif5+0x9b0>
movslq 0x30(%rsp),%rcx
lea    0x1(%rcx),%rax
mov    %rax,0x30(%rsp)
mov    0x150(%rsp),%rax
mov    %ebp,0x4(%rax,%rcx,4)
mov    0x158(%rsp),%rax
movb   $0x0,0x1(%rax,%rcx,1)
cmpl   $0x0,0x178(%rsp)
jle    1b00 <scan_motif5+0x9b0>
mov    %rcx,0x40(%rsp)
movss  %xmm1,0x24(%rsp)
cmpl   $0x0,0x10(%rsp)
mov    0xb0(%rsp),%r8
mov    0xa8(%rsp),%rax
jle    1c9e <scan_motif5+0xb4e>
movabs $0x100000000,%rcx
lea    (%rcx,%r12,1),%rbp
add    $0xffffffffffffffff,%rbp
mov    $0x1,%ecx
cmpq   $0x8,0x8(%rsp)
jb     1c2b <scan_motif5+0xadb>
lea    0x1(%r11),%edx
mov    0x88(%rsp),%rsi
add    %edx,%esi
cmp    %edx,%esi
jl     1c2b <scan_motif5+0xadb>
cmpq   $0x0,0xd8(%rsp)
jne    1c2b <scan_motif5+0xadb>
movslq %edx,%rdx
mov    0x68(%rsp),%rsi
add    %rdx,%rsi
cmp    %rsi,0xd0(%rsp)
jae    1ae9 <scan_motif5+0x999>
add    %r10,%rdx
cmp    0xc8(%rsp),%rdx
jb     1c2b <scan_motif5+0xadb>
cmpq   $0x20,0x8(%rsp)
jae    1b0f <scan_motif5+0x9bf>
xor    %edx,%edx
jmp    1bdc <scan_motif5+0xa8c>
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rcx
mov    0x18(%rsp),%rsi
jmp    18c2 <scan_motif5+0x772>
mov    %rbp,0x58(%rsp)
cmpq   $0x20,0xc0(%rsp)
jae    1b23 <scan_motif5+0x9d3>
xor    %ecx,%ecx
jmp    1b88 <scan_motif5+0xa38>
mov    0x98(%rsp),%rdx
mov    %r15,%rbp
mov    0x38(%rsp),%rbx
xor    %ecx,%ecx
movabs $0x4000000000,%r9
nop
mov    %rbp,%rsi
sar    $0x20,%rsi
movups (%r10,%rsi,1),%xmm0
movups 0x10(%r10,%rsi,1),%xmm1
movups %xmm0,0x1(%rdi,%rcx,1)
movups %xmm1,0x11(%rdi,%rcx,1)
mov    %rbx,%rsi
sar    $0x20,%rsi
movups (%r10,%rsi,1),%xmm0
movups 0x10(%r10,%rsi,1),%xmm1
movups %xmm0,0x21(%rdi,%rcx,1)
movups %xmm1,0x31(%rdi,%rcx,1)
add    $0x40,%rcx
add    %r9,%rbx
add    %r9,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1b40 <scan_motif5+0x9f0>
testb  $0x1,0x90(%rsp)
01
mov    0x58(%rsp),%rbp
je     1bb5 <scan_motif5+0xa65>
or     $0x1,%rcx
lea    (%rcx,%rbp,1),%edx
movslq %edx,%rdx
movups (%r10,%rdx,1),%xmm0
movups 0x10(%r10,%rdx,1),%xmm1
movups %xmm0,(%rdi,%rcx,1)
movups %xmm1,0x10(%rdi,%rcx,1)
mov    0x80(%rsp),%rcx
cmp    %rcx,0x8(%rsp)
je     1c9e <scan_motif5+0xb4e>
mov    0x80(%rsp),%rdx
mov    0x78(%rsp),%rcx
testb  $0x18,0x8(%rsp)
je     1c2b <scan_motif5+0xadb>
mov    0x18(%rsp),%rcx
add    %edx,%ecx
shl    $0x20,%rcx
movabs $0x800000000,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rsi
sar    $0x20,%rsi
mov    (%r10,%rsi,1),%rsi
mov    %rsi,0x1(%rdi,%rdx,1)
add    $0x8,%rdx
add    %rbx,%rcx
cmp    %rdx,%rax
jne    1c00 <scan_motif5+0xab0>
mov    0xa0(%rsp),%rcx
cmp    %rax,0x8(%rsp)
je     1c9e <scan_motif5+0xb4e>
mov    %rcx,%rdx
test   $0x1,%r8b
jne    1c44 <scan_motif5+0xaf4>
add    %ecx,%ebp
movslq %ebp,%rax
mov    (%r10,%rax,1),%al
mov    %al,(%rdi,%rcx,1)
lea    0x1(%rcx),%rdx
not    %rcx
cmp    0xe0(%rsp),%rcx
movabs $0x200000000,%rbp
je     1c9e <scan_motif5+0xb4e>
lea    (%rdx,%r11,1),%eax
shl    $0x20,%rax
mov    0x18(%rsp),%rcx
add    %edx,%ecx
shl    $0x20,%rcx
xchg   %ax,%ax
mov    %rax,%rsi
sar    $0x20,%rsi
movzbl (%r10,%rsi,1),%ebx
mov    %bl,(%rdi,%rdx,1)
mov    %rcx,%rsi
sar    $0x20,%rsi
movzbl (%r10,%rsi,1),%ebx
mov    %bl,0x1(%rdi,%rdx,1)
add    $0x2,%rdx
add    %rbp,%rax
add    %rbp,%rcx
cmp    %rdx,%r8
jne    1c70 <scan_motif5+0xb20>
mov    0xb8(%rsp),%rbx
movb   $0x0,(%rbx)
mov    0x10(%rsp),%rsi
mov    %rbx,%rdx
mov    $0x1,%ecx
mov    %r11,%rbp
call   1050 <num2seq@plt>
mov    0x150(%rsp),%rax
mov    0x40(%rsp),%rcx
mov    0x4(%rax,%rcx,4),%ecx
mov    0x170(%rsp),%rdi
lea    0x322(%rip),%rsi
mov    0x178(%rsp),%edx
movss  0x24(%rsp),%xmm0
mov    %rbx,%r8
xor    %r9d,%r9d
call   1040 <fprintf@plt>
mov    %rbp,%r11
mov    0x70(%rsp),%r10
mov    0x28(%rsp),%rdi
mov    0x60(%rsp),%r9
movss  0x20(%rsp),%xmm0
mov    0x38(%rsp),%rcx
mov    0x168(%rsp),%ebx
mov    0x18(%rsp),%rsi
mov    0x48(%rsp),%ebp
jmp    18c2 <scan_motif5+0x772>
mov    0x28(%rsp),%rdi
cmpl   $0x0,0x178(%rsp)
jg     1d4d <scan_motif5+0xbfd>
jmp    1d72 <scan_motif5+0xc22>
mov    %rax,0x30(%rsp)
mov    0x28(%rsp),%rdi
cmpl   $0x0,0x178(%rsp)
jle    1d72 <scan_motif5+0xc22>
mov    $0x1,%esi
mov    0x10(%rsp),%rbx
mov    %ebx,%edx
call   1060 <free_cvector@plt>
add    $0xffffffff,%ebx
mov    0xb8(%rsp),%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1060 <free_cvector@plt>
mov    0x30(%rsp),%rax
add    $0x118,%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_motif5(float** %0, float* %1, i8* %2, i8* %3, i32 %4, i32 %5, float %6, i32* %7, i8* %8, i32 %9, i32 %10, i32* %11, i32 %12) {
%14 = alloca float**
%15 = alloca float*
%16 = alloca i8*
%17 = alloca i8*
%18 = alloca i32
%19 = alloca i32
%20 = alloca float
%21 = alloca i32*
%22 = alloca i8*
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32*
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i8
%32 = alloca float
%33 = alloca i32
%34 = alloca float
%35 = alloca i32
%36 = alloca i8*
%37 = alloca i8*
%38 = alloca i32
store float** %0, float*** %14
store float* %1, float** %15
store i8* %2, i8** %16
store i8* %3, i8** %17
store i32 %4, i32* %18
store i32 %5, i32* %19
store float %6, float* %20
store i32* %7, i32** %21
store i8* %8, i8** %22
store i32 %9, i32* %23
store i32 %10, i32* %24
store i32* %11, i32** %25
store i32 %12, i32* %26
%39 = load i32, i32* %19
%40 = load i32, i32* %18
%41 = sub nsw i32 %39, %40
store i32 %41, i32* %30
store i32 0, i32* %33
%42 = load i32, i32* %26
%43 = icmp sgt i32 %42, 0
br i1 %43, label %44, label %50
44: ; preds = %13
%45 = load i32, i32* %18
%46 = call i8* @cvector(i32 1, i32 %45)
store i8* %46, i8** %37
%47 = load i32, i32* %18
%48 = sub nsw i32 %47, 1
%49 = call i8* @cvector(i32 0, i32 %48)
store i8* %49, i8** %36
br label %50
50: ; preds = %44, %13
%51 = load i32, i32* %18
%52 = sub nsw i32 0, %51
store i32 %52, i32* %38
store i32 1, i32* %35
store i32 1, i32* %27
br label %53
53: ; preds = %177, %50
%54 = load i32, i32* %27
%55 = load i32, i32* %30
%56 = icmp sle i32 %54, %55
br i1 %56, label %57, label %180
57: ; preds = %53
%58 = load i32, i32* %27
%59 = load i32, i32* %38
%60 = sub nsw i32 %58, %59
%61 = load i32, i32* %24
%62 = icmp sgt i32 %60, %61
br i1 %62, label %63, label %176
63: ; preds = %57
store float 0.000000e+00, float* %34
store i32 1, i32* %28
br label %64
64: ; preds = %109, %63
%65 = load i32, i32* %28
%66 = load i32, i32* %18
%67 = icmp sle i32 %65, %66
br i1 %67, label %68, label %112
68: ; preds = %64
%69 = load i8*, i8** %16
%70 = load i32, i32* %27
%71 = load i32, i32* %28
%72 = add nsw i32 %70, %71
%73 = sub nsw i32 %72, 1
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8, i8* %69, i64 %74
%76 = load i8, i8* %75
store i8 %76, i8* %31
%77 = load i8, i8* %31
%78 = sext i8 %77 to i32
%79 = icmp sgt i32 %78, 0
%80 = zext i1 %79 to i32
%81 = load i8, i8* %31
%82 = sext i8 %81 to i32
%83 = icmp slt i32 %82, 5
%84 = zext i1 %83 to i32
%85 = and i32 %80, %84
%86 = icmp ne i32 %85, 0
br i1 %86, label %87, label %100
87: ; preds = %68
%88 = load float**, float*** %14
%89 = load i8, i8* %31
%90 = sext i8 %89 to i64
%91 = getelementptr inbounds float*, float** %88, i64 %90
%92 = load float*, float** %91
%93 = load i32, i32* %28
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float, float* %92, i64 %94
%96 = load float, float* %95
store float %96, float* %32
%97 = load float, float* %32
%98 = load float, float* %34
%99 = fadd float %98, %97
store float %99, float* %34
br label %108
100: ; preds = %68
%101 = load float*, float** %15
%102 = load i32, i32* %28
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds float, float* %101, i64 %103
%105 = load float, float* %104
%106 = load float, float* %34
%107 = fadd float %106, %105
store float %107, float* %34
br label %108
108: ; preds = %100, %87
br label %109
109: ; preds = %108
%110 = load i32, i32* %28
%111 = add nsw i32 %110, 1
store i32 %111, i32* %28
br label %64
112: ; preds = %64
%113 = load float, float* %34
%114 = load float, float* %20
%115 = fcmp oge float %113, %114
br i1 %115, label %116, label %175
116: ; preds = %112
%117 = load i32, i32* %27
store i32 %117, i32* %38
%118 = load i32, i32* %33
%119 = add nsw i32 %118, 1
store i32 %119, i32* %33
%120 = load i32, i32* %19
%121 = load i32, i32* %27
%122 = sub nsw i32 %120, %121
%123 = load i32*, i32** %21
%124 = load i32, i32* %33
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i32, i32* %123, i64 %125
store i32 %122, i32* %126
%127 = load i32, i32* %35
%128 = trunc i32 %127 to i8
%129 = load i8*, i8** %22
%130 = load i32, i32* %33
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i8, i8* %129, i64 %131
store i8 %128, i8* %132
%133 = load i32, i32* %26
%134 = icmp sgt i32 %133, 0
br i1 %134, label %135, label %174
135: ; preds = %116
store i32 1, i32* %28
br label %136
136: ; preds = %153, %135
%137 = load i32, i32* %28
%138 = load i32, i32* %18
%139 = icmp sle i32 %137, %138
br i1 %139, label %140, label %156
140: ; preds = %136
%141 = load i8*, i8** %16
%142 = load i32, i32* %27
%143 = load i32, i32* %28
%144 = add nsw i32 %142, %143
%145 = sub nsw i32 %144, 1
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i8, i8* %141, i64 %146
%148 = load i8, i8* %147
%149 = load i8*, i8** %37
%150 = load i32, i32* %28
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i8, i8* %149, i64 %151
store i8 %148, i8* %152
br label %153
153: ; preds = %140
%154 = load i32, i32* %28
%155 = add nsw i32 %154, 1
store i32 %155, i32* %28
br label %136
156: ; preds = %136
%157 = load i8*, i8** %36
%158 = call i32 @sprintf(i8* %157, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%159 = load i8*, i8** %37
%160 = load i32, i32* %18
%161 = load i8*, i8** %36
%162 = call i32 @num2seq(i8* %159, i32 %160, i8* %161, i32 1)
%163 = load i32*, i32** %25
%164 = load i32, i32* %26
%165 = load i32*, i32** %21
%166 = load i32, i32* %33
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i32, i32* %165, i64 %167
%169 = load i32, i32* %168
%170 = load float, float* %34
%171 = load i8*, i8** %36
%172 = load i32, i32* %35
%173 = call i32 @fprintf(i32* %163, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i32 %164, i32 %169, float %170, i8* %171, i32 %172)
br label %174
174: ; preds = %156, %116
br label %175
175: ; preds = %174, %112
br label %176
176: ; preds = %175, %57
br label %177
177: ; preds = %176
%178 = load i32, i32* %27
%179 = add nsw i32 %178, 1
store i32 %179, i32* %27
br label %53
180: ; preds = %53
store i32 0, i32* %35
%181 = load i32, i32* %18
%182 = sub nsw i32 0, %181
store i32 %182, i32* %38
%183 = load i32, i32* %23
%184 = icmp eq i32 %183, 1
br i1 %184, label %185, label %314
185: ; preds = %180
%186 = load i8*, i8** %16
%187 = load i8*, i8** %17
%188 = load i32, i32* %19
%189 = call i32 @revcomp(i8* %186, i8* %187, i32 %188)
store i32 1, i32* %27
br label %190
190: ; preds = %310, %185
%191 = load i32, i32* %27
%192 = load i32, i32* %30
%193 = icmp sle i32 %191, %192
br i1 %193, label %194, label %313
194: ; preds = %190
%195 = load i32, i32* %27
%196 = load i32, i32* %38
%197 = sub nsw i32 %195, %196
%198 = load i32, i32* %24
%199 = icmp sgt i32 %197, %198
br i1 %199, label %200, label %309
200: ; preds = %194
store float 0.000000e+00, float* %34
store i32 1, i32* %28
br label %201
201: ; preds = %246, %200
%202 = load i32, i32* %28
%203 = load i32, i32* %18
%204 = icmp sle i32 %202, %203
br i1 %204, label %205, label %249
205: ; preds = %201
%206 = load i8*, i8** %17
%207 = load i32, i32* %27
%208 = load i32, i32* %28
%209 = add nsw i32 %207, %208
%210 = sub nsw i32 %209, 1
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i8, i8* %206, i64 %211
%213 = load i8, i8* %212
store i8 %213, i8* %31
%214 = load i8, i8* %31
%215 = sext i8 %214 to i32
%216 = icmp sgt i32 %215, 0
%217 = zext i1 %216 to i32
%218 = load i8, i8* %31
%219 = sext i8 %218 to i32
%220 = icmp slt i32 %219, 5
%221 = zext i1 %220 to i32
%222 = and i32 %217, %221
%223 = icmp ne i32 %222, 0
br i1 %223, label %224, label %237
224: ; preds = %205
%225 = load float**, float*** %14
%226 = load i8, i8* %31
%227 = sext i8 %226 to i64
%228 = getelementptr inbounds float*, float** %225, i64 %227
%229 = load float*, float** %228
%230 = load i32, i32* %28
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds float, float* %229, i64 %231
%233 = load float, float* %232
store float %233, float* %32
%234 = load float, float* %32
%235 = load float, float* %34
%236 = fadd float %235, %234
store float %236, float* %34
br label %245
237: ; preds = %205
%238 = load float*, float** %15
%239 = load i32, i32* %28
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds float, float* %238, i64 %240
%242 = load float, float* %241
%243 = load float, float* %34
%244 = fadd float %243, %242
store float %244, float* %34
br label %245
245: ; preds = %237, %224
br label %246
246: ; preds = %245
%247 = load i32, i32* %28
%248 = add nsw i32 %247, 1
store i32 %248, i32* %28
br label %201
249: ; preds = %201
%250 = load float, float* %34
%251 = load float, float* %20
%252 = fcmp oge float %250, %251
br i1 %252, label %253, label %308
253: ; preds = %249
%254 = load i32, i32* %27
store i32 %254, i32* %38
%255 = load i32, i32* %33
%256 = add nsw i32 %255, 1
store i32 %256, i32* %33
%257 = load i32, i32* %27
%258 = load i32*, i32** %21
%259 = load i32, i32* %33
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds i32, i32* %258, i64 %260
store i32 %257, i32* %261
%262 = load i8*, i8** %22
%263 = load i32, i32* %33
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i8, i8* %262, i64 %264
store i8 0, i8* %265
%266 = load i32, i32* %26
%267 = icmp sgt i32 %266, 0
br i1 %267, label %268, label %307
268: ; preds = %253
store i32 1, i32* %28
br label %269
269: ; preds = %286, %268
%270 = load i32, i32* %28
%271 = load i32, i32* %18
%272 = icmp sle i32 %270, %271
br i1 %272, label %273, label %289
273: ; preds = %269
%274 = load i8*, i8** %17
%275 = load i32, i32* %27
%276 = load i32, i32* %28
%277 = add nsw i32 %275, %276
%278 = sub nsw i32 %277, 1
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds i8, i8* %274, i64 %279
%281 = load i8, i8* %280
%282 = load i8*, i8** %37
%283 = load i32, i32* %28
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i8, i8* %282, i64 %284
store i8 %281, i8* %285
br label %286
286: ; preds = %273
%287 = load i32, i32* %28
%288 = add nsw i32 %287, 1
store i32 %288, i32* %28
br label %269
289: ; preds = %269
%290 = load i8*, i8** %36
%291 = call i32 @sprintf(i8* %290, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%292 = load i8*, i8** %37
%293 = load i32, i32* %18
%294 = load i8*, i8** %36
%295 = call i32 @num2seq(i8* %292, i32 %293, i8* %294, i32 1)
%296 = load i32*, i32** %25
%297 = load i32, i32* %26
%298 = load i32*, i32** %21
%299 = load i32, i32* %33
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i32, i32* %298, i64 %300
%302 = load i32, i32* %301
%303 = load float, float* %34
%304 = load i8*, i8** %36
%305 = load i32, i32* %35
%306 = call i32 @fprintf(i32* %296, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i32 %297, i32 %302, float %303, i8* %304, i32 %305)
br label %307
307: ; preds = %289, %253
br label %308
308: ; preds = %307, %249
br label %309
309: ; preds = %308, %194
br label %310
310: ; preds = %309
%311 = load i32, i32* %27
%312 = add nsw i32 %311, 1
store i32 %312, i32* %27
br label %190
313: ; preds = %190
br label %314
314: ; preds = %313, %180
%315 = load i32, i32* %26
%316 = icmp sgt i32 %315, 0
br i1 %316, label %317, label %325
317: ; preds = %314
%318 = load i8*, i8** %37
%319 = load i32, i32* %18
%320 = call i32 @free_cvector(i8* %318, i32 1, i32 %319)
%321 = load i8*, i8** %36
%322 = load i32, i32* %18
%323 = sub nsw i32 %322, 1
%324 = call i32 @free_cvector(i8* %321, i32 0, i32 %323)
br label %325
325: ; preds = %317, %314
%326 = load i32, i32* %33
ret i32 %326
}

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