#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 */

/* Variables and functions */
int /*<<< orphan*/ baseinfo(char, long, char, char *, char, int, char *);
char *malloc(int);
int /*<<< orphan*/ sprintf(char *, char *, char, char);
char *write_best_pairs(int num_residue, long num_helixs, long **helix_idx,
                       long *bp_idx, long *helix_marker, long **base_pairs,
                       long **seidx, char **ResName, char *ChainID,
                       long *ResSeq, char **Miscs, char *bseq, double *BPRS,
                       long *num_bp, long **pair_num) {
  char b1[512], b2[512], wc[3];
  long i, i_order, j, j_order, k, ii, marker_n;
  long num_helix = 0, num_1bp = 0, num_nwc = 0, idx = 0, num_bsp = 0;
  char *secStruct;
  secStruct = malloc(sizeof(char) * (num_residue + 1));
  for (i = 0; i < num_residue; i++)
    secStruct[i] = 'S';
  secStruct[num_residue] = '\0';
  for (ii = 1; ii <= num_helixs; ii++) {
    idx = ii;
    if (num_helixs == 1)
      idx = 0;
    for (i = helix_idx[ii][1]; i <= helix_idx[ii][2]; i++) {
      num_bsp++;
      k = bp_idx[i];
      i_order = base_pairs[k][1];
      j_order = base_pairs[k][2];
      if (base_pairs[k][3] != 2)
        num_nwc++;
      sprintf(wc, "%c%c", (base_pairs[k][3] == 2) ? '-' : '*',
              (base_pairs[k][3] > 0) ? '-' : '*');
      j = seidx[i_order][1];
      baseinfo(ChainID[j], ResSeq[j], Miscs[j][2], ResName[j], bseq[i_order], 1,
               b1);
      j = seidx[j_order][1];
      baseinfo(ChainID[j], ResSeq[j], Miscs[j][2], ResName[j], bseq[j_order], 2,
               b2);
      marker_n = 0;
      if (helix_marker[i]) {
        ++num_helix;
        if ((!idx && helix_idx[num_helix][3] == 1) ||
            (idx && helix_idx[idx][3] == 1)) {
          num_1bp++;
          marker_n = 1;
        } else if (ii != helix_idx[ii][2]) {
          marker_n = 9;
        }
      }
      pair_num[1][num_bsp] = i_order;
      pair_num[2][num_bsp] = j_order;
      pair_num[3][num_bsp] = marker_n;
      if (wc[0] != '*') {
        if (i_order > j_order) {
          secStruct[i_order - 1] = 'H';
          secStruct[j_order - 1] = 'H';
        } else {
          secStruct[i_order - 1] = 'H';
          secStruct[j_order - 1] = 'H';
        }
      }
    }
  }
  *num_bp = num_bsp;
  return secStruct;
}


x86 assembly (clang, -O0):
<write_best_pairs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4b0,%rsp
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movq   $0x0,-0x478(%rbp)
movq   $0x0,-0x480(%rbp)
movq   $0x0,-0x488(%rbp)
movq   $0x0,-0x490(%rbp)
movq   $0x0,-0x498(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x4a0(%rbp)
movq   $0x0,-0x440(%rbp)
mov    -0x440(%rbp),%rax
movslq -0x4(%rbp),%rcx
cmp    %rcx,%rax
jge    120f <write_best_pairs+0xdf>
mov    -0x4a0(%rbp),%rax
mov    -0x440(%rbp),%rcx
movb   $0x53,(%rax,%rcx,1)
mov    -0x440(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x440(%rbp)
jmp    11d2 <write_best_pairs+0xa2>
mov    -0x4a0(%rbp),%rax
movslq -0x4(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movq   $0x1,-0x468(%rbp)
mov    -0x468(%rbp),%rax
cmp    -0x10(%rbp),%rax
jg     167b <write_best_pairs+0x54b>
mov    -0x468(%rbp),%rax
mov    %rax,-0x490(%rbp)
cmpq   $0x1,-0x10(%rbp)
jne    125e <write_best_pairs+0x12e>
movq   $0x0,-0x490(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x468(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x440(%rbp)
mov    -0x440(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x468(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
jg     165f <write_best_pairs+0x52f>
mov    -0x498(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x498(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x440(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x460(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x460(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x448(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x460(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x458(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x460(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmpq   $0x2,0x18(%rax)
je     1320 <write_best_pairs+0x1f0>
mov    -0x488(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x488(%rbp)
lea    -0x433(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    -0x460(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rax),%rdx
mov    $0x2a,%eax
mov    $0x2d,%ecx
cmp    $0x2,%rdx
cmove  %ecx,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    -0x460(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    0x18(%rax),%rsi
mov    $0x2a,%eax
mov    $0x2d,%edx
cmp    $0x0,%rsi
cmovg  %edx,%eax
lea    0xc88(%rip),%rsi
movsbl %cl,%edx
movsbl %al,%ecx
call   1050 <sprintf@plt>
mov    0x10(%rbp),%rax
mov    -0x448(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x450(%rbp)
mov    0x20(%rbp),%rax
mov    -0x450(%rbp),%rcx
mov    (%rax,%rcx,1),%dil
mov    0x28(%rbp),%rax
mov    -0x450(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    0x30(%rbp),%rax
mov    -0x450(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2(%rax),%dl
mov    0x18(%rbp),%rax
mov    -0x450(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x38(%rbp),%rax
mov    -0x448(%rbp),%r8
mov    (%rax,%r8,1),%r8b
lea    -0x230(%rbp),%rax
mov    $0x1,%r9d
movsbl %dil,%edi
movsbl %dl,%edx
movsbl %r8b,%r8d
mov    %rax,(%rsp)
call   1030 <baseinfo@plt>
mov    0x10(%rbp),%rax
mov    -0x458(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x450(%rbp)
mov    0x20(%rbp),%rax
mov    -0x450(%rbp),%rcx
mov    (%rax,%rcx,1),%dil
mov    0x28(%rbp),%rax
mov    -0x450(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    0x30(%rbp),%rax
mov    -0x450(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2(%rax),%dl
mov    0x18(%rbp),%rax
mov    -0x450(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x38(%rbp),%rax
mov    -0x458(%rbp),%r8
mov    (%rax,%r8,1),%r8b
lea    -0x430(%rbp),%rax
mov    $0x2,%r9d
movsbl %dil,%edi
movsbl %dl,%edx
movsbl %r8b,%r8d
mov    %rax,(%rsp)
call   1030 <baseinfo@plt>
movq   $0x0,-0x470(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x440(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     156f <write_best_pairs+0x43f>
mov    -0x478(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x478(%rbp)
cmpq   $0x0,-0x490(%rbp)
jne    14f0 <write_best_pairs+0x3c0>
mov    -0x18(%rbp),%rax
mov    -0x478(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmpq   $0x1,0x18(%rax)
je     1518 <write_best_pairs+0x3e8>
cmpq   $0x0,-0x490(%rbp)
je     153a <write_best_pairs+0x40a>
mov    -0x18(%rbp),%rax
mov    -0x490(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmpq   $0x1,0x18(%rax)
jne    153a <write_best_pairs+0x40a>
mov    -0x480(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x480(%rbp)
movq   $0x1,-0x470(%rbp)
jmp    156a <write_best_pairs+0x43a>
mov    -0x468(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x468(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
je     1565 <write_best_pairs+0x435>
movq   $0x9,-0x470(%rbp)
jmp    156a <write_best_pairs+0x43a>
jmp    156f <write_best_pairs+0x43f>
mov    -0x448(%rbp),%rdx
mov    0x50(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x498(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x458(%rbp),%rdx
mov    0x50(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x498(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x470(%rbp),%rdx
mov    0x50(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0x498(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movsbl -0x433(%rbp),%eax
cmp    $0x2a,%eax
je     1643 <write_best_pairs+0x513>
mov    -0x448(%rbp),%rax
cmp    -0x458(%rbp),%rax
jle    1612 <write_best_pairs+0x4e2>
mov    -0x4a0(%rbp),%rax
mov    -0x448(%rbp),%rcx
sub    $0x1,%rcx
movb   $0x48,(%rax,%rcx,1)
mov    -0x4a0(%rbp),%rax
mov    -0x458(%rbp),%rcx
sub    $0x1,%rcx
movb   $0x48,(%rax,%rcx,1)
jmp    163e <write_best_pairs+0x50e>
mov    -0x4a0(%rbp),%rax
mov    -0x448(%rbp),%rcx
sub    $0x1,%rcx
movb   $0x48,(%rax,%rcx,1)
mov    -0x4a0(%rbp),%rax
mov    -0x458(%rbp),%rcx
sub    $0x1,%rcx
movb   $0x48,(%rax,%rcx,1)
jmp    1643 <write_best_pairs+0x513>
jmp    1648 <write_best_pairs+0x518>
mov    -0x440(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x440(%rbp)
jmp    1278 <write_best_pairs+0x148>
jmp    1664 <write_best_pairs+0x534>
mov    -0x468(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x468(%rbp)
jmp    1229 <write_best_pairs+0xf9>
mov    -0x498(%rbp),%rcx
mov    0x48(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x4a0(%rbp),%rax
add    $0x4b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<write_best_pairs>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x498,%rsp
mov    %r9,0x68(%rsp)
mov    %r8,0x50(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rdx,0x20(%rsp)
mov    %rsi,0x18(%rsp)
mov    %edi,%r14d
lea    0x1(%r14),%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
movslq %r14d,%r14
test   %r14d,%r14d
jle    1191 <write_best_pairs+0x51>
mov    %rbx,%rdi
mov    $0x53,%esi
mov    %r14,%rdx
call   1040 <memset@plt>
mov    %rbx,0x40(%rsp)
movb   $0x0,(%rbx,%r14,1)
cmpq   $0x0,0x18(%rsp)
jle    1458 <write_best_pairs+0x318>
mov    $0x1,%edi
xor    %edx,%edx
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    0x20(%rsp),%rsi
jmp    11da <write_best_pairs+0x9a>
nopl   0x0(%rax)
mov    0x58(%rsp),%rdx
add    %r15,%rdx
lea    0x1(%rdi),%rax
cmp    0x18(%rsp),%rdi
mov    %rax,%rdi
je     145a <write_best_pairs+0x31a>
mov    (%rsi,%rdi,8),%rcx
mov    0x8(%rcx),%rax
cmp    0x10(%rcx),%rax
jg     11c8 <write_best_pairs+0x88>
cmpq   $0x1,0x18(%rsp)
mov    %rdi,%rsi
mov    $0x0,%ecx
cmove  %rcx,%rsi
mov    %rsi,0x60(%rsp)
lea    -0x1(%rax),%rcx
mov    %rcx,0x88(%rsp)
mov    0x50(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x80(%rsp)
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x78(%rsp)
mov    %rdx,0x58(%rsp)
lea    0x8(,%rdx,8),%rax
mov    %rax,0x70(%rsp)
xor    %r15d,%r15d
mov    %rdi,0x30(%rsp)
jmp    1271 <write_best_pairs+0x131>
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi,%rdi,8),%rax
mov    0x88(%rsp),%rcx
add    %r15,%rcx
add    $0x1,%rcx
add    $0x1,%r15
cmp    0x10(%rax),%rcx
jge    11c0 <write_best_pairs+0x80>
mov    0x78(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    0x68(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
mov    0x8(%rax),%rbx
mov    0x10(%rax),%r14
mov    0x18(%rax),%rax
xor    %ecx,%ecx
cmp    $0x2,%rax
sete   %cl
xor    %esi,%esi
test   %rax,%rax
setg   %sil
lea    (%rcx,%rcx,2),%edx
add    $0x2a,%edx
lea    (%rsi,%rsi,2),%ecx
add    $0x2a,%ecx
lea    0x15(%rsp),%rdi
lea    0xd47(%rip),%rsi
call   1060 <sprintf@plt>
mov    0x4d0(%rsp),%rax
mov    (%rax,%rbx,8),%rax
mov    0x8(%rax),%rax
mov    0x4e0(%rsp),%rcx
movsbl (%rcx,%rax,1),%edi
mov    0x4e8(%rsp),%rcx
mov    (%rcx,%rax,8),%rsi
mov    0x4f0(%rsp),%r12
mov    (%r12,%rax,8),%rcx
movsbl 0x2(%rcx),%edx
mov    0x4d8(%rsp),%rbp
mov    0x0(%rbp,%rax,8),%rcx
mov    0x4f8(%rsp),%r13
mov    %rbx,0x38(%rsp)
movsbl 0x0(%r13,%rbx,1),%r8d
lea    0x290(%rsp),%rax
mov    %rax,(%rsp)
mov    $0x1,%r9d
call   1030 <baseinfo@plt>
mov    0x4d0(%rsp),%rax
mov    (%rax,%r14,8),%rax
mov    0x8(%rax),%rax
mov    0x4e0(%rsp),%rcx
movsbl (%rcx,%rax,1),%edi
mov    0x4e8(%rsp),%rcx
mov    (%rcx,%rax,8),%rsi
mov    (%r12,%rax,8),%rcx
movsbl 0x2(%rcx),%edx
mov    0x0(%rbp,%rax,8),%rcx
movsbl 0x0(%r13,%r14,1),%r8d
lea    0x90(%rsp),%rax
mov    %rax,(%rsp)
mov    $0x2,%r9d
call   1030 <baseinfo@plt>
mov    0x80(%rsp),%rax
cmpq   $0x0,(%rax,%r15,8)
je     13b0 <write_best_pairs+0x270>
mov    0x28(%rsp),%rax
lea    0x1(%rax),%rcx
cmpq   $0x1,0x18(%rsp)
jne    13d0 <write_best_pairs+0x290>
mov    0x20(%rsp),%rsi
mov    0x8(%rsi,%rax,8),%rdx
jmp    13de <write_best_pairs+0x29e>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x20(%rsp),%rsi
mov    0x30(%rsp),%rdi
mov    0x38(%rsp),%rbx
jmp    140a <write_best_pairs+0x2ca>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x20(%rsp),%rsi
mov    0x60(%rsp),%rax
mov    (%rsi,%rax,8),%rdx
mov    $0x1,%eax
cmpq   $0x1,0x18(%rdx)
mov    0x30(%rsp),%rdi
mov    0x38(%rsp),%rbx
je     1405 <write_best_pairs+0x2c5>
mov    (%rsi,%rdi,8),%rax
xor    %edx,%edx
cmp    0x10(%rax),%rdi
setne  %dl
lea    (%rdx,%rdx,8),%rax
mov    %rcx,0x28(%rsp)
mov    0x510(%rsp),%rdx
mov    0x8(%rdx),%rcx
mov    0x70(%rsp),%rbp
add    %rbp,%rcx
mov    %rbx,(%rcx,%r15,8)
mov    0x10(%rdx),%rcx
add    %rbp,%rcx
mov    %r14,(%rcx,%r15,8)
mov    0x18(%rdx),%rcx
add    %rbp,%rcx
mov    %rax,(%rcx,%r15,8)
cmpb   $0x2a,0x15(%rsp)
je     1250 <write_best_pairs+0x110>
mov    0x40(%rsp),%rax
movb   $0x48,-0x1(%rbx,%rax,1)
movb   $0x48,-0x1(%r14,%rax,1)
jmp    1250 <write_best_pairs+0x110>
xor    %edx,%edx
mov    0x508(%rsp),%rax
mov    %rdx,(%rax)
mov    0x40(%rsp),%rax
add    $0x498,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [5 x i8] c"%c%c\00"
define noalias i8* @write_best_pairs(i32 %0, i64 %1, i64** nocapture %2, i64* nocapture %3, i64* nocapture %4, i64** nocapture %5, i64** nocapture %6, i8** nocapture %7, i8* nocapture %8, i64* nocapture %9, i8** nocapture %10, i8* nocapture %11, double* nocapture readnone %12, i64* nocapture writeonly %13, i64** nocapture %14) {
%16 = alloca [512 x i8]
%17 = alloca [512 x i8]
%18 = alloca [3 x i8]
%19 = getelementptr inbounds [512 x i8], [512 x i8]* %16, i64 0, i64 0
%20 = getelementptr inbounds [512 x i8], [512 x i8]* %17, i64 0, i64 0
%21 = getelementptr inbounds [3 x i8], [3 x i8]* %18, i64 0, i64 0
%22 = add nsw i32 %0, 1
%23 = tail call i8* @malloc(i32 %22)
%24 = sext i32 %0 to i64
%25 = icmp sgt i32 %0, 0
br i1 %25, label %26, label %27
26: ; preds = %15
br label %27
27: ; preds = %26, %15
%28 = getelementptr inbounds i8, i8* %23, i64 %24
store i8 0, i8* %28
%29 = icmp slt i64 %1, 1
br i1 %29, label %152, label %30
30: ; preds = %27
%31 = icmp eq i64 %1, 1
%32 = getelementptr inbounds i64*, i64** %14, i64 1
%33 = getelementptr inbounds i64*, i64** %14, i64 2
%34 = getelementptr inbounds i64*, i64** %14, i64 3
br label %35
35: ; preds = %30, %147
%36 = phi i64 [ 0, %30 ], [ %149, %147 ]
%37 = phi i64 [ 0, %30 ], [ %148, %147 ]
%38 = phi i64 [ 1, %30 ], [ %150, %147 ]
%39 = getelementptr inbounds i64*, i64** %2, i64 %38
%40 = load i64*, i64** %39
%41 = getelementptr inbounds i64, i64* %40, i64 1
%42 = load i64, i64* %41
%43 = getelementptr inbounds i64, i64* %40, i64 2
%44 = load i64, i64* %43
%45 = icmp sgt i64 %42, %44
br i1 %45, label %147, label %46
46: ; preds = %35
%47 = select i1 %31, i64 0, i64 %38
%48 = getelementptr inbounds i64*, i64** %2, i64 %47
br label %49
49: ; preds = %46, %141
%50 = phi i64 [ %42, %46 ], [ %142, %141 ]
%51 = phi i64 [ %36, %46 ], [ %53, %141 ]
%52 = phi i64 [ %37, %46 ], [ %127, %141 ]
%53 = add nsw i64 %51, 1
%54 = getelementptr inbounds i64, i64* %3, i64 %50
%55 = load i64, i64* %54
%56 = getelementptr inbounds i64*, i64** %5, i64 %55
%57 = load i64*, i64** %56
%58 = getelementptr inbounds i64, i64* %57, i64 1
%59 = load i64, i64* %58
%60 = getelementptr inbounds i64, i64* %57, i64 2
%61 = load i64, i64* %60
%62 = getelementptr inbounds i64, i64* %57, i64 3
%63 = load i64, i64* %62
%64 = icmp eq i64 %63, 2
%65 = select i1 %64, i8 45, i8 42
%66 = icmp sgt i64 %63, 0
%67 = select i1 %66, i8 45, i8 42
%68 = call i32 @sprintf(i8* %21, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i8 signext %65, i8 signext %67)
%69 = getelementptr inbounds i64*, i64** %6, i64 %59
%70 = load i64*, i64** %69
%71 = getelementptr inbounds i64, i64* %70, i64 1
%72 = load i64, i64* %71
%73 = getelementptr inbounds i8, i8* %8, i64 %72
%74 = load i8, i8* %73
%75 = getelementptr inbounds i64, i64* %9, i64 %72
%76 = load i64, i64* %75
%77 = getelementptr inbounds i8*, i8** %10, i64 %72
%78 = load i8*, i8** %77
%79 = getelementptr inbounds i8, i8* %78, i64 2
%80 = load i8, i8* %79
%81 = getelementptr inbounds i8*, i8** %7, i64 %72
%82 = load i8*, i8** %81
%83 = getelementptr inbounds i8, i8* %11, i64 %59
%84 = load i8, i8* %83
%85 = call i32 @baseinfo(i8 signext %74, i64 %76, i8 signext %80, i8* %82, i8 signext %84, i32 1, i8* %19)
%86 = getelementptr inbounds i64*, i64** %6, i64 %61
%87 = load i64*, i64** %86
%88 = getelementptr inbounds i64, i64* %87, i64 1
%89 = load i64, i64* %88
%90 = getelementptr inbounds i8, i8* %8, i64 %89
%91 = load i8, i8* %90
%92 = getelementptr inbounds i64, i64* %9, i64 %89
%93 = load i64, i64* %92
%94 = getelementptr inbounds i8*, i8** %10, i64 %89
%95 = load i8*, i8** %94
%96 = getelementptr inbounds i8, i8* %95, i64 2
%97 = load i8, i8* %96
%98 = getelementptr inbounds i8*, i8** %7, i64 %89
%99 = load i8*, i8** %98
%100 = getelementptr inbounds i8, i8* %11, i64 %61
%101 = load i8, i8* %100
%102 = call i32 @baseinfo(i8 signext %91, i64 %93, i8 signext %97, i8* %99, i8 signext %101, i32 2, i8* %20)
%103 = getelementptr inbounds i64, i64* %4, i64 %50
%104 = load i64, i64* %103
%105 = icmp eq i64 %104, 0
br i1 %105, label %125, label %106
106: ; preds = %49
%107 = add nsw i64 %52, 1
br i1 %31, label %108, label %114
108: ; preds = %106
%109 = getelementptr inbounds i64*, i64** %2, i64 %107
%110 = load i64*, i64** %109
%111 = getelementptr inbounds i64, i64* %110, i64 3
%112 = load i64, i64* %111
%113 = icmp eq i64 %112, 1
br i1 %113, label %125, label %119
114: ; preds = %106
%115 = load i64*, i64** %48
%116 = getelementptr inbounds i64, i64* %115, i64 3
%117 = load i64, i64* %116
%118 = icmp eq i64 %117, 1
br i1 %118, label %125, label %119
119: ; preds = %108, %114
%120 = load i64*, i64** %39
%121 = getelementptr inbounds i64, i64* %120, i64 2
%122 = load i64, i64* %121
%123 = icmp eq i64 %38, %122
%124 = select i1 %123, i64 0, i64 9
br label %125
125: ; preds = %108, %114, %119, %49
%126 = phi i64 [ 0, %49 ], [ %124, %119 ], [ 1, %114 ], [ 1, %108 ]
%127 = phi i64 [ %52, %49 ], [ %107, %119 ], [ %107, %114 ], [ %107, %108 ]
%128 = load i64*, i64** %32
%129 = getelementptr inbounds i64, i64* %128, i64 %53
store i64 %59, i64* %129
%130 = load i64*, i64** %33
%131 = getelementptr inbounds i64, i64* %130, i64 %53
store i64 %61, i64* %131
%132 = load i64*, i64** %34
%133 = getelementptr inbounds i64, i64* %132, i64 %53
store i64 %126, i64* %133
%134 = load i8, i8* %21
%135 = icmp eq i8 %134, 42
br i1 %135, label %141, label %136
136: ; preds = %125
%137 = add nsw i64 %59, -1
%138 = getelementptr inbounds i8, i8* %23, i64 %137
store i8 72, i8* %138
%139 = add nsw i64 %61, -1
%140 = getelementptr inbounds i8, i8* %23, i64 %139
store i8 72, i8* %140
br label %141
141: ; preds = %136, %125
%142 = add nsw i64 %50, 1
%143 = load i64*, i64** %39
%144 = getelementptr inbounds i64, i64* %143, i64 2
%145 = load i64, i64* %144
%146 = icmp slt i64 %50, %145
br i1 %146, label %49, label %147
147: ; preds = %141, %35
%148 = phi i64 [ %37, %35 ], [ %127, %141 ]
%149 = phi i64 [ %36, %35 ], [ %53, %141 ]
%150 = add nuw i64 %38, 1
%151 = icmp eq i64 %38, %1
br i1 %151, label %152, label %35
152: ; preds = %147, %27
%153 = phi i64 [ 0, %27 ], [ %149, %147 ]
store i64 %153, i64* %13
ret i8* %23
}