#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 */
int /*<<< orphan*/ printf(char *, ...);
double roundf(float);
void printout(int nres, char *seq, char *predi, char *title, float **proba,
              FILE *fp2) {
  int ires;
  int nlines, nl, helix_counter = 0, sheet_counter = 0, coil_counter = 0,
                  total_counter = 0;
  printf("\n\n>%s\n", title + 1);
  nlines = nres / 50 + 1;
  for (nl = 1; nl < nlines; nl++) {
    for (ires = (nl - 1) * 50 + 1; ires <= nl * 50; ires++) {
      printf("%c", seq[ires]);
      if (ires % 10 == 0)
        printf("%c", ' ');
    }
    printf("    %s\n", "Sequence");
    for (ires = (nl - 1) * 50 + 1; ires <= nl * 50; ires++) {
      printf("%c", predi[ires]);
      if (ires % 10 == 0)
        printf("%c", ' ');
    }
    printf("    %s\n", "Predicted Sec. Struct.");
    printf("\n");
  }
  for (ires = (nlines - 1) * 50 + 1; ires <= nlines * 50; ires++) {
    if (ires <= nres) {
      printf("%c", seq[ires]);
    } else {
      printf("%c", ' ');
    }
    if (ires % 10 == 0)
      printf("%c", ' ');
  }
  printf("    %s\n", "Sequence");
  for (ires = (nlines - 1) * 50 + 1; ires <= nlines * 50; ires++) {
    if (ires <= nres) {
      printf("%c", predi[ires]);
    } else {
      printf("%c", ' ');
    }
    if (ires % 10 == 0)
      printf("%c", ' ');
  }
  printf("    %s\n", "Predicted Sec. Struct.");
  printf("\n\nSequence length %d", nres);
  printf("\n\n");
  if (fp2 != NULL) {
    printf("SEQ\tPRD\tH\tE\tC\n");
    for (ires = 1; ires <= nres; ires++) {
      printf(" %c\t%c\t%.0f\t%.0f\t%.0f\n", seq[ires], predi[ires],
             roundf(proba[ires][1] * 1000), roundf(proba[ires][2] * 1000),
             roundf(proba[ires][3] * 1000));
      if (predi[ires] == 'H') {
        helix_counter++;
        total_counter++;
      }
      if (predi[ires] == 'E') {
        sheet_counter++;
        total_counter++;
      }
      if (predi[ires] == 'C') {
        coil_counter++;
        total_counter++;
      }
    }
    printf("\n\nGORIV\n");
    printf("Alpha helix     (H) :     %d is   %.2f%%\n", helix_counter,
           (float)(helix_counter * 100) / total_counter);
    printf("Extended Strand (E) :     %d is   %.2f%%\n", sheet_counter,
           (float)(sheet_counter * 100) / total_counter);
    printf("Random Coil     (C) :     %d is   %.2f%%\n", coil_counter,
           (float)(coil_counter * 100) / total_counter);
  }
}


x86 assembly (clang, -O0):
<printout>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x20(%rbp),%rsi
add    $0x1,%rsi
lea    0xe9a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
mov    $0x32,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    12bf <printout+0x19f>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
imul   $0x32,%eax,%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
imul   $0x32,-0x3c(%rbp),%ecx
cmp    %ecx,%eax
jg     1207 <printout+0xe7>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xe45(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    11f4 <printout+0xd4>
lea    0xe23(%rip),%rdi
mov    $0x20,%esi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    11f9 <printout+0xd9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a4 <printout+0x84>
lea    0xe00(%rip),%rdi
lea    0xe01(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
imul   $0x32,%eax,%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
imul   $0x32,-0x3c(%rbp),%ecx
cmp    %ecx,%eax
jg     128e <printout+0x16e>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xdbe(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    127b <printout+0x15b>
lea    0xd9c(%rip),%rdi
mov    $0x20,%esi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1280 <printout+0x160>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    122b <printout+0x10b>
lea    0xd79(%rip),%rdi
lea    0xd83(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xda2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1189 <printout+0x69>
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
imul   $0x32,%eax,%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
imul   $0x32,-0x38(%rbp),%ecx
cmp    %ecx,%eax
jg     1355 <printout+0x235>
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1308 <printout+0x1e8>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xd0f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    131b <printout+0x1fb>
lea    0xcfc(%rip),%rdi
mov    $0x20,%esi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1342 <printout+0x222>
lea    0xcd5(%rip),%rdi
mov    $0x20,%esi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1347 <printout+0x227>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ce <printout+0x1ae>
lea    0xcb2(%rip),%rdi
lea    0xcb3(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
imul   $0x32,%eax,%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
imul   $0x32,-0x38(%rbp),%ecx
cmp    %ecx,%eax
jg     1400 <printout+0x2e0>
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     13b3 <printout+0x293>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xc64(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13c6 <printout+0x2a6>
lea    0xc51(%rip),%rdi
mov    $0x20,%esi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    13ed <printout+0x2cd>
lea    0xc2a(%rip),%rdi
mov    $0x20,%esi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13f2 <printout+0x2d2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1379 <printout+0x259>
lea    0xc07(%rip),%rdi
lea    0xc11(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%esi
lea    0xc17(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xc1e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpq   $0x0,-0x30(%rbp)
je     160b <printout+0x4eb>
lea    0xc08(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     158b <printout+0x46b>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x64(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0xb6e(%rip),%xmm0
mulss  0x4(%rax),%xmm0
call   1040 <roundf@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0xb4b(%rip),%xmm0
mulss  0x8(%rax),%xmm0
call   1040 <roundf@plt>
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0xb28(%rip),%xmm0
mulss  0xc(%rax),%xmm0
call   1040 <roundf@plt>
mov    -0x68(%rbp),%esi
mov    -0x64(%rbp),%edx
movsd  -0x60(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x58(%rbp),%xmm0
lea    0xb61(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x48,%eax
jne    152a <printout+0x40a>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x45,%eax
jne    1551 <printout+0x431>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x43,%eax
jne    1578 <printout+0x458>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    157d <printout+0x45d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1454 <printout+0x334>
lea    0xae2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x40(%rbp),%esi
imul   $0x64,-0x40(%rbp),%eax
cvtsi2ss %eax,%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xac5(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x44(%rbp),%esi
imul   $0x64,-0x44(%rbp),%eax
cvtsi2ss %eax,%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xac9(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x48(%rbp),%esi
imul   $0x64,-0x48(%rbp),%eax
cvtsi2ss %eax,%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xacd(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<printout>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,0x30(%rsp)
mov    %r8,0x40(%rsp)
mov    %rdx,0x28(%rsp)
mov    %rsi,(%rsp)
mov    %edi,%ebx
lea    0x1(%rcx),%rsi
lea    0xe96(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,0x10(%rsp)
movslq %ebx,%rcx
imul   $0x51eb851f,%rcx,%rdx
mov    %rdx,%rax
shr    $0x3f,%rax
sar    $0x24,%rdx
add    %eax,%edx
mov    %rdx,0x18(%rsp)
mov    %rcx,0x20(%rsp)
cmp    $0x32,%ecx
jge    11d6 <printout+0x96>
imul   $0x32,0x18(%rsp),%r13d
lea    0x1(%r13),%r14d
lea    0x32(%r13),%r15d
cmp    %r15d,%r14d
jle    131b <printout+0x1db>
lea    0xe4d(%rip),%rdi
lea    0xe4e(%rip),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x10(%rsp),%r15
jmp    13b4 <printout+0x274>
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x38(%rsp)
mov    $0x1,%r13d
mov    $0x1,%r12d
xor    %eax,%eax
jmp    124f <printout+0x10f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0xe04(%rip),%rdi
lea    0xe05(%rip),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xdef(%rip),%rdi
lea    0xdf9(%rip),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r13
mov    0x8(%rsp),%rax
add    $0x32,%eax
add    $0x32,%r12d
cmp    0x38(%rsp),%r13
je     11a0 <printout+0x60>
movslq %eax,%r14
imul   $0x32,%r13d,%ebp
cmp    $0x80000030,%ebp
mov    %r14,0x8(%rsp)
jle    1200 <printout+0xc0>
movslq %ebp,%r15
mov    %r12d,%ebx
jmp    127c <printout+0x13c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
add    $0x1,%ebx
cmp    %r15,%r14
jge    12b0 <printout+0x170>
mov    (%rsp),%rax
movsbl 0x1(%rax,%r14,1),%edi
call   1030 <putchar@plt>
imul   $0xcccccccd,%ebx,%eax
add    $0x19999998,%eax
ror    %eax
cmp    $0x19999998,%eax
ja     1270 <printout+0x130>
mov    $0x20,%edi
call   1030 <putchar@plt>
jmp    1270 <printout+0x130>
nopl   0x0(%rax,%rax,1)
lea    0xd54(%rip),%rdi
lea    0xd55(%rip),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
cmp    $0x80000031,%ebp
mov    0x28(%rsp),%r14
jl     1215 <printout+0xd5>
mov    %r12d,%ebx
mov    0x8(%rsp),%rbp
jmp    12f0 <printout+0x1b0>
add    $0x1,%rbp
add    $0x1,%ebx
cmp    %r15,%rbp
jge    1215 <printout+0xd5>
movsbl 0x1(%r14,%rbp,1),%edi
call   1030 <putchar@plt>
imul   $0xcccccccd,%ebx,%eax
add    $0x19999998,%eax
ror    %eax
cmp    $0x19999998,%eax
ja     12e0 <printout+0x1a0>
mov    $0x20,%edi
call   1030 <putchar@plt>
jmp    12e0 <printout+0x1a0>
mov    %r13d,%eax
or     $0x1,%eax
mov    %eax,0x8(%rsp)
movslq %eax,%rbp
mov    $0x1,%r12d
mov    (%rsp),%rbx
jmp    136b <printout+0x22b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
call   1030 <putchar@plt>
lea    (%r12,%r13,1),%eax
imul   $0xcccccccd,%eax,%eax
add    $0x19999998,%eax
ror    %eax
cmp    $0x19999998,%eax
jbe    1380 <printout+0x240>
add    $0x1,%rbp
add    $0x1,%r12d
cmp    $0x33,%r12d
je     138c <printout+0x24c>
mov    $0x20,%edi
cmp    0x20(%rsp),%rbp
jg     1340 <printout+0x200>
movsbl (%rbx,%rbp,1),%edi
jmp    1340 <printout+0x200>
nopl   (%rax)
mov    $0x20,%edi
call   1030 <putchar@plt>
jmp    135d <printout+0x21d>
lea    0xc78(%rip),%rdi
lea    0xc79(%rip),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
cmp    %r15d,%r14d
mov    0x28(%rsp),%r14
mov    0x10(%rsp),%r15
jle    152d <printout+0x3ed>
lea    0xc50(%rip),%rdi
lea    0xc5a(%rip),%rsi
xor    %ebp,%ebp
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xc61(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xcf8(%rip),%rdi
call   1040 <puts@plt>
cmpq   $0x0,0x30(%rsp)
je     151e <printout+0x3de>
lea    0xce2(%rip),%rdi
call   1040 <puts@plt>
test   %r15d,%r15d
jle    158c <printout+0x44c>
add    $0x1,%r15d
mov    %r15,0x10(%rsp)
xor    %r14d,%r14d
mov    $0x1,%r15d
xor    %ebx,%ebx
xor    %r13d,%r13d
xor    %ebp,%ebp
mov    0x28(%rsp),%r12
nopw   0x0(%rax,%rax,1)
mov    %ebp,0x8(%rsp)
mov    (%rsp),%rax
movsbl (%rax,%r15,1),%eax
mov    %eax,0x20(%rsp)
movsbl (%r12,%r15,1),%eax
mov    %eax,0x38(%rsp)
mov    %r13d,%ebp
mov    0x40(%rsp),%r13
mov    0x0(%r13,%r15,8),%rax
movss  0x4(%rax),%xmm0
movss  0xb9c(%rip),%xmm1
mulss  %xmm1,%xmm0
call   1060 <roundf@plt>
movsd  %xmm0,0x18(%rsp)
mov    0x0(%r13,%r15,8),%rax
movss  0x8(%rax),%xmm0
mulss  0xb7b(%rip),%xmm0
call   1060 <roundf@plt>
movsd  %xmm0,0x30(%rsp)
mov    0x0(%r13,%r15,8),%rax
mov    %ebp,%r13d
mov    0x8(%rsp),%ebp
movss  0xc(%rax),%xmm0
mulss  0xb57(%rip),%xmm0
call   1060 <roundf@plt>
movaps %xmm0,%xmm2
lea    0xb90(%rip),%rdi
mov    0x20(%rsp),%esi
mov    0x38(%rsp),%edx
movsd  0x18(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mov    $0x3,%al
call   1050 <printf@plt>
movzbl (%r12,%r15,1),%eax
xor    %ecx,%ecx
cmp    $0x48,%al
sete   %cl
add    %ecx,%ebp
add    %ecx,%r14d
xor    %ecx,%ecx
cmp    $0x45,%al
sete   %cl
add    %ecx,%r13d
add    %ecx,%r14d
xor    %ecx,%ecx
cmp    $0x43,%al
sete   %cl
add    %ecx,%ebx
add    %ecx,%r14d
add    $0x1,%r15
cmp    %r15,0x10(%rsp)
jne    1430 <printout+0x2f0>
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
movss  %xmm0,(%rsp)
jmp    1599 <printout+0x459>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movslq 0x8(%rsp),%rbp
mov    $0x1,%ebx
jmp    156d <printout+0x42d>
nopl   0x0(%rax)
call   1030 <putchar@plt>
lea    (%rbx,%r13,1),%eax
imul   $0xcccccccd,%eax,%eax
add    $0x19999998,%eax
ror    %eax
cmp    $0x19999998,%eax
jbe    1580 <printout+0x440>
add    $0x1,%rbp
add    $0x1,%ebx
cmp    $0x33,%ebx
je     13b4 <printout+0x274>
mov    $0x20,%edi
cmp    0x20(%rsp),%rbp
jg     1540 <printout+0x400>
movsbl (%r14,%rbp,1),%edi
jmp    1540 <printout+0x400>
mov    $0x20,%edi
call   1030 <putchar@plt>
jmp    155d <printout+0x41d>
xorps  %xmm0,%xmm0
movss  %xmm0,(%rsp)
xor    %r13d,%r13d
xor    %ebx,%ebx
lea    0xb4b(%rip),%rdi
call   1040 <puts@plt>
imul   $0x64,%ebp,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xaa0(%rip),%rdi
mov    %ebp,%esi
mov    $0x1,%al
call   1050 <printf@plt>
imul   $0x64,%r13d,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xaa6(%rip),%rdi
mov    %r13d,%esi
mov    $0x1,%al
call   1050 <printf@plt>
imul   $0x64,%ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xaac(%rip),%rdi
mov    %ebx,%esi
mov    $0x1,%al
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <printf@plt>

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

LLVM IR (-O2):
@.str = [7 x i8] c"\0A\0A>%s\0A\00"
@.str.2 = [8 x i8] c" %s\0A\00"
@.str.3 = [9 x i8] c"Sequence\00"
@.str.4 = [23 x i8] c"Predicted Sec. Struct.\00"
@.str.6 = [21 x i8] c"\0A\0ASequence length %d\00"
@.str.9 = [23 x i8] c" %c\09%c\09%.0f\09%.0f\09%.0f\0A\00"
@.str.11 = [42 x i8] c"Alpha helix (H) : %d is %.2f%%\0A\00"
@.str.12 = [42 x i8] c"Extended Strand (E) : %d is %.2f%%\0A\00"
@.str.13 = [42 x i8] c"Random Coil (C) : %d is %.2f%%\0A\00"
@str = [2 x i8] c"\0A\00"
@str.14 = [14 x i8] c"SEQ\09PRD\09H\09E\09C\00"
@str.15 = [8 x i8] c"\0A\0AGORIV\00"
define void @printout(i32 %0, i8* nocapture %1, i8* nocapture %2, i8* %3, float** nocapture %4, i32* readnone %5) {
%7 = getelementptr inbounds i8, i8* %3, i64 1
%8 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i8* %7)
%9 = sdiv i32 %0, 50
%10 = icmp slt i32 %0, 50
br i1 %10, label %64, label %11
11: ; preds = %6
%12 = add nsw i32 %9, 1
%13 = zext i32 %12 to i64
br label %14
14: ; preds = %11, %58
%15 = phi i64 [ 1, %11 ], [ %61, %58 ]
%16 = phi i32 [ 0, %11 ], [ %62, %58 ]
%17 = or i32 %16, 1
%18 = sext i32 %17 to i64
%19 = trunc i64 %15 to i32
%20 = mul i32 %19, 50
%21 = icmp slt i32 %20, -2147483599
br i1 %21, label %22, label %24
22: ; preds = %14
%23 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0))
br label %58
24: ; preds = %14
%25 = sext i32 %20 to i64
br label %26
26: ; preds = %24, %37
%27 = phi i64 [ %18, %24 ], [ %38, %37 ]
%28 = getelementptr inbounds i8, i8* %1, i64 %27
%29 = load i8, i8* %28
%30 = sext i8 %29 to i32
%31 = tail call i32 @putchar(i32 %30)
%32 = trunc i64 %27 to i32
%33 = srem i32 %32, 10
%34 = icmp eq i32 %33, 0
br i1 %34, label %35, label %37
35: ; preds = %26
%36 = tail call i32 @putchar(i32 32)
br label %37
37: ; preds = %26, %35
%38 = add nsw i64 %27, 1
%39 = icmp slt i64 %27, %25
br i1 %39, label %26, label %40
40: ; preds = %37
%41 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0))
br i1 %21, label %58, label %42
42: ; preds = %40
%43 = sext i32 %20 to i64
br label %44
44: ; preds = %42, %55
%45 = phi i64 [ %18, %42 ], [ %56, %55 ]
%46 = getelementptr inbounds i8, i8* %2, i64 %45
%47 = load i8, i8* %46
%48 = sext i8 %47 to i32
%49 = tail call i32 @putchar(i32 %48)
%50 = trunc i64 %45 to i32
%51 = srem i32 %50, 10
%52 = icmp eq i32 %51, 0
br i1 %52, label %53, label %55
53: ; preds = %44
%54 = tail call i32 @putchar(i32 32)
br label %55
55: ; preds = %44, %53
%56 = add nsw i64 %45, 1
%57 = icmp slt i64 %45, %43
br i1 %57, label %44, label %58
58: ; preds = %55, %22, %40
%59 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.4, i64 0, i64 0))
%60 = tail call i32 @putchar(i32 10)
%61 = add nuw nsw i64 %15, 1
%62 = add nuw i32 %16, 50
%63 = icmp eq i64 %61, %13
br i1 %63, label %64, label %14
64: ; preds = %58, %6
%65 = mul i32 %9, 50
%66 = or i32 %65, 1
%67 = add i32 %65, 50
%68 = icmp sgt i32 %66, %67
br i1 %68, label %69, label %71
69: ; preds = %64
%70 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0))
br label %121
71: ; preds = %64
%72 = or i32 %65, 1
%73 = sext i32 %72 to i64
%74 = sext i32 %0 to i64
%75 = add i32 %65, 51
br label %76
76: ; preds = %71, %91
%77 = phi i64 [ %73, %71 ], [ %92, %91 ]
%78 = icmp sgt i64 %77, %74
br i1 %78, label %83, label %79
79: ; preds = %76
%80 = getelementptr inbounds i8, i8* %1, i64 %77
%81 = load i8, i8* %80
%82 = sext i8 %81 to i32
br label %83
83: ; preds = %76, %79
%84 = phi i32 [ %82, %79 ], [ 32, %76 ]
%85 = tail call i32 @putchar(i32 %84)
%86 = trunc i64 %77 to i32
%87 = srem i32 %86, 10
%88 = icmp eq i32 %87, 0
br i1 %88, label %89, label %91
89: ; preds = %83
%90 = tail call i32 @putchar(i32 32)
br label %91
91: ; preds = %83, %89
%92 = add nsw i64 %77, 1
%93 = trunc i64 %92 to i32
%94 = icmp eq i32 %75, %93
br i1 %94, label %95, label %76
95: ; preds = %91
%96 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0))
br i1 %68, label %121, label %97
97: ; preds = %95
%98 = or i32 %65, 1
%99 = sext i32 %98 to i64
%100 = sext i32 %0 to i64
%101 = add i32 %65, 51
br label %102
102: ; preds = %97, %117
%103 = phi i64 [ %99, %97 ], [ %118, %117 ]
%104 = icmp sgt i64 %103, %100
br i1 %104, label %109, label %105
105: ; preds = %102
%106 = getelementptr inbounds i8, i8* %2, i64 %103
%107 = load i8, i8* %106
%108 = sext i8 %107 to i32
br label %109
109: ; preds = %102, %105
%110 = phi i32 [ %108, %105 ], [ 32, %102 ]
%111 = tail call i32 @putchar(i32 %110)
%112 = trunc i64 %103 to i32
%113 = srem i32 %112, 10
%114 = icmp eq i32 %113, 0
br i1 %114, label %115, label %117
115: ; preds = %109
%116 = tail call i32 @putchar(i32 32)
br label %117
117: ; preds = %109, %115
%118 = add nsw i64 %103, 1
%119 = trunc i64 %118 to i32
%120 = icmp eq i32 %101, %119
br i1 %120, label %121, label %102
121: ; preds = %117, %69, %95
%122 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.4, i64 0, i64 0))
%123 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.6, i64 0, i64 0), i32 %0)
%124 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str, i64 0, i64 0))
%125 = icmp eq i32* %5, null
br i1 %125, label %199, label %126
126: ; preds = %121
%127 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @str.14, i64 0, i64 0))
%128 = icmp slt i32 %0, 1
br i1 %128, label %178, label %129
129: ; preds = %126
%130 = add nuw i32 %0, 1
%131 = zext i32 %130 to i64
br label %132
132: ; preds = %129, %132
%133 = phi i64 [ 1, %129 ], [ %174, %132 ]
%134 = phi i32 [ 0, %129 ], [ %173, %132 ]
%135 = phi i32 [ 0, %129 ], [ %172, %132 ]
%136 = phi i32 [ 0, %129 ], [ %168, %132 ]
%137 = phi i32 [ 0, %129 ], [ %164, %132 ]
%138 = getelementptr inbounds i8, i8* %1, i64 %133
%139 = load i8, i8* %138
%140 = sext i8 %139 to i32
%141 = getelementptr inbounds i8, i8* %2, i64 %133
%142 = load i8, i8* %141
%143 = sext i8 %142 to i32
%144 = getelementptr inbounds float*, float** %4, i64 %133
%145 = load float*, float** %144
%146 = getelementptr inbounds float, float* %145, i64 1
%147 = load float, float* %146
%148 = fmul float %147, 1.000000e+03
%149 = tail call double @roundf(float %148)
%150 = load float*, float** %144
%151 = getelementptr inbounds float, float* %150, i64 2
%152 = load float, float* %151
%153 = fmul float %152, 1.000000e+03
%154 = tail call double @roundf(float %153)
%155 = load float*, float** %144
%156 = getelementptr inbounds float, float* %155, i64 3
%157 = load float, float* %156
%158 = fmul float %157, 1.000000e+03
%159 = tail call double @roundf(float %158)
%160 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.9, i64 0, i64 0), i32 %140, i32 %143, double %149, double %154, double %159)
%161 = load i8, i8* %141
%162 = icmp eq i8 %161, 72
%163 = zext i1 %162 to i32
%164 = add nuw nsw i32 %137, %163
%165 = add nsw i32 %134, %163
%166 = icmp eq i8 %161, 69
%167 = zext i1 %166 to i32
%168 = add nuw nsw i32 %136, %167
%169 = add nsw i32 %165, %167
%170 = icmp eq i8 %161, 67
%171 = zext i1 %170 to i32
%172 = add nuw nsw i32 %135, %171
%173 = add nsw i32 %169, %171
%174 = add nuw nsw i64 %133, 1
%175 = icmp eq i64 %174, %131
br i1 %175, label %176, label %132
176: ; preds = %132
%177 = sitofp i32 %173 to float
br label %178
178: ; preds = %176, %126
%179 = phi i32 [ 0, %126 ], [ %164, %176 ]
%180 = phi i32 [ 0, %126 ], [ %168, %176 ]
%181 = phi i32 [ 0, %126 ], [ %172, %176 ]
%182 = phi float [ 0.000000e+00, %126 ], [ %177, %176 ]
%183 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.15, i64 0, i64 0))
%184 = mul nsw i32 %179, 100
%185 = sitofp i32 %184 to float
%186 = fdiv float %185, %182
%187 = fpext float %186 to double
%188 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.11, i64 0, i64 0), i32 %179, double %187)
%189 = mul nsw i32 %180, 100
%190 = sitofp i32 %189 to float
%191 = fdiv float %190, %182
%192 = fpext float %191 to double
%193 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.12, i64 0, i64 0), i32 %180, double %192)
%194 = mul nsw i32 %181, 100
%195 = sitofp i32 %194 to float
%196 = fdiv float %195, %182
%197 = fpext float %196 to double
%198 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.13, i64 0, i64 0), i32 %181, double %197)
br label %199
199: ; preds = %178, %121
ret void
}