#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 */
char **cmatrix(int, long, int /*<<< orphan*/, int);
int /*<<< orphan*/ free_cmatrix(char **, int, long, int /*<<< orphan*/, int);
int /*<<< orphan*/ free_lvector(long *, int, long);
long **lmatrix(int, long, int, int);
long *lvector(int, long);
int /*<<< orphan*/ sprintf(char *, char *, char *, char, long, char);
scalar_t__ strcmp(char *, char *);
long **residue_idx(long num, long *ResSeq, char **Miscs, char *ChainID,
                   char **ResName, long *num_residue) {
  char iCode;
  char **bidx;
  long i, n, **seidx, *temp;
  bidx = cmatrix(1, num, 0, 12);
  temp = lvector(1, num);
  for (i = 1; i <= num; i++) {
    iCode = (Miscs == NULL) ? ' ' : Miscs[i][2];
    sprintf(bidx[i], "%3s%c%4ld%c", ResName[i], ChainID[i], ResSeq[i], iCode);
  }
  for (i = 1; i < num; i++)
    temp[i] = strcmp(bidx[i + 1], bidx[i]) ? 1 : 0;
  temp[num] = 1;
  n = 0;
  for (i = 1; i <= num; i++)
    if (temp[i])
      ++n;
  seidx = lmatrix(1, n, 1, 2);
  n = 0;
  for (i = 1; i <= num; i++)
    if (temp[i])
      seidx[++n][2] = i;
  for (i = 2; i <= n; i++)
    seidx[i][1] = seidx[i - 1][2] + 1;
  seidx[1][1] = 1;
  *num_residue = n;
  free_cmatrix(bidx, 1, num, 0, 12);
  free_lvector(temp, 1, num);
  return seidx;
}


x86 assembly (clang, -O0):
<residue_idx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%rsi
mov    $0x1,%edi
xor    %edx,%edx
mov    $0xc,%ecx
call   1030 <cmatrix@plt>
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rsi
mov    $0x1,%edi
call   1090 <lvector@plt>
mov    %rax,-0x60(%rbp)
movq   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jg     1256 <residue_idx+0xe6>
cmpq   $0x0,-0x18(%rbp)
jne    11e9 <residue_idx+0x79>
mov    $0x20,%eax
mov    %eax,-0x64(%rbp)
jmp    11fc <residue_idx+0x8c>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x2(%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %al,-0x31(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    -0x10(%rbp),%rcx
mov    -0x48(%rbp),%rsi
mov    (%rcx,%rsi,8),%r8
lea    0xdc8(%rip),%rsi
movsbl %al,%ecx
movsbl -0x31(%rbp),%r9d
call   1080 <sprintf@plt>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    11c3 <residue_idx+0x53>
movq   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    12bb <residue_idx+0x14b>
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rdi
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   1050 <strcmp@plt>
mov    %rax,%rdx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%rdx
cmovne %ecx,%eax
movslq %eax,%rdx
mov    -0x60(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    125e <residue_idx+0xee>
mov    -0x60(%rbp),%rax
mov    -0x8(%rbp),%rcx
movq   $0x1,(%rax,%rcx,8)
movq   $0x0,-0x50(%rbp)
movq   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jg     131e <residue_idx+0x1ae>
mov    -0x60(%rbp),%rax
mov    -0x48(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1308 <residue_idx+0x198>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    130d <residue_idx+0x19d>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    12db <residue_idx+0x16b>
mov    -0x50(%rbp),%rsi
mov    $0x1,%edx
mov    $0x2,%ecx
mov    %edx,%edi
call   1070 <lmatrix@plt>
mov    %rax,-0x58(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jg     139e <residue_idx+0x22e>
mov    -0x60(%rbp),%rax
mov    -0x48(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1388 <residue_idx+0x218>
mov    -0x48(%rbp),%rcx
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rdx
mov    %rdx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x50(%rbp)
mov    0x8(%rax,%rdx,8),%rax
mov    %rcx,0x10(%rax)
jmp    138d <residue_idx+0x21d>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1347 <residue_idx+0x1d7>
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jg     13ed <residue_idx+0x27d>
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rax),%rcx
add    $0x1,%rcx
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %rcx,0x8(%rax)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    13a6 <residue_idx+0x236>
mov    -0x58(%rbp),%rax
mov    0x8(%rax),%rax
movq   $0x1,0x8(%rax)
mov    -0x50(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x1,%esi
xor    %ecx,%ecx
mov    $0xc,%r8d
call   1060 <free_cmatrix@plt>
mov    -0x60(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x1,%esi
call   1040 <free_lvector@plt>
mov    -0x58(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<residue_idx>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r9,%r12
mov    %r8,%r13
mov    %rcx,%rbp
mov    %rdx,%rbx
mov    %rsi,%r15
mov    %rdi,%r14
mov    $0x1,%edi
mov    %r14,%rsi
xor    %edx,%edx
mov    $0xc,%ecx
call   1030 <cmatrix@plt>
mov    %rax,(%rsp)
mov    $0x1,%edi
mov    %r14,%rsi
call   1090 <lvector@plt>
test   %r14,%r14
jle    1289 <residue_idx+0x119>
mov    %rax,0x8(%rsp)
mov    %r12,0x10(%rsp)
mov    %r14,%r12
xor    %r14d,%r14d
jmp    1204 <residue_idx+0x94>
mov    $0x20,%al
mov    (%rsp),%rcx
mov    0x8(%rcx,%r14,8),%rdi
mov    0x8(%r13,%r14,8),%rdx
movsbl 0x1(%rbp,%r14,1),%ecx
mov    0x8(%r15,%r14,8),%r8
movsbl %al,%r9d
lea    0xe0a(%rip),%rsi
call   1080 <sprintf@plt>
add    $0x1,%r14
cmp    %r14,%r12
je     1214 <residue_idx+0xa4>
test   %rbx,%rbx
je     11d0 <residue_idx+0x60>
mov    0x8(%rbx,%r14,8),%rax
movzbl 0x2(%rax),%eax
jmp    11d2 <residue_idx+0x62>
mov    %r12,%r14
cmp    $0x2,%r12
mov    0x8(%rsp),%r15
mov    (%rsp),%r12
jl     1256 <residue_idx+0xe6>
mov    $0x1,%ebx
nopl   0x0(%rax,%rax,1)
lea    0x1(%rbx),%rbp
mov    (%r12,%rbx,8),%rsi
mov    0x8(%r12,%rbx,8),%rdi
call   1050 <strcmp@plt>
xor    %ecx,%ecx
test   %rax,%rax
setne  %cl
mov    %rcx,(%r15,%rbx,8)
mov    %rbp,%rbx
cmp    %rbp,%r14
jne    1230 <residue_idx+0xc0>
movq   $0x1,(%r15,%r14,8)
test   %r14,%r14
mov    0x10(%rsp),%r12
jle    1294 <residue_idx+0x124>
lea    -0x1(%r14),%rbx
mov    %r14d,%eax
and    $0x3,%eax
cmp    $0x3,%rbx
jae    12b4 <residue_idx+0x144>
mov    $0x1,%ecx
xor    %esi,%esi
test   %rax,%rax
jne    12fa <residue_idx+0x18a>
jmp    1312 <residue_idx+0x1a2>
movq   $0x1,(%rax,%r14,8)
mov    %rax,%r15
xor    %ebx,%ebx
mov    $0x1,%edi
xor    %esi,%esi
mov    $0x1,%edx
mov    $0x2,%ecx
call   1070 <lmatrix@plt>
mov    %rax,%r13
jmp    1479 <residue_idx+0x309>
mov    %r14,%rdx
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
xor    %ecx,%ecx
nop
cmpq   $0x1,0x8(%r15,%rcx,8)
sbb    $0xffffffffffffffff,%rsi
cmpq   $0x1,0x10(%r15,%rcx,8)
sbb    $0xffffffffffffffff,%rsi
cmpq   $0x1,0x18(%r15,%rcx,8)
sbb    $0xffffffffffffffff,%rsi
cmpq   $0x1,0x20(%r15,%rcx,8)
sbb    $0xffffffffffffffff,%rsi
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    12c0 <residue_idx+0x150>
add    $0x1,%rcx
test   %rax,%rax
je     1312 <residue_idx+0x1a2>
lea    (%r15,%rcx,8),%rcx
xor    %edx,%edx
cmpq   $0x1,(%rcx,%rdx,8)
sbb    $0xffffffffffffffff,%rsi
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1300 <residue_idx+0x190>
mov    $0x1,%edi
mov    $0x1,%edx
mov    $0x2,%ecx
call   1070 <lmatrix@plt>
mov    %rax,%r13
test   %r14,%r14
jle    1391 <residue_idx+0x221>
test   %rbx,%rbx
je     1398 <residue_idx+0x228>
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
mov    $0x1,%eax
xor    %ebx,%ebx
jmp    1362 <residue_idx+0x1f2>
cs nopw 0x0(%rax,%rax,1)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
je     139f <residue_idx+0x22f>
cmpq   $0x0,(%r15,%rax,8)
je     1376 <residue_idx+0x206>
mov    0x8(%r13,%rbx,8),%rdx
add    $0x1,%rbx
mov    %rax,0x10(%rdx)
cmpq   $0x0,0x8(%r15,%rax,8)
je     1350 <residue_idx+0x1e0>
lea    0x1(%rax),%rdx
mov    0x8(%r13,%rbx,8),%rsi
add    $0x1,%rbx
mov    %rdx,0x10(%rsi)
jmp    1350 <residue_idx+0x1e0>
xor    %ebx,%ebx
jmp    1479 <residue_idx+0x309>
mov    $0x1,%eax
xor    %ebx,%ebx
test   $0x1,%r14b
je     13b9 <residue_idx+0x249>
cmpq   $0x0,(%r15,%rax,8)
je     13b9 <residue_idx+0x249>
mov    0x8(%r13,%rbx,8),%rcx
add    $0x1,%rbx
mov    %rax,0x10(%rcx)
cmp    $0x2,%rbx
jl     1479 <residue_idx+0x309>
mov    0x8(%r13),%rcx
lea    -0x1(%rbx),%rdx
lea    -0x2(%rbx),%rdi
mov    %edx,%eax
and    $0x3,%eax
mov    $0x2,%esi
cmp    $0x3,%rdi
jb     1446 <residue_idx+0x2d6>
and    $0xfffffffffffffffc,%rdx
neg    %rdx
mov    $0x2,%esi
nopl   0x0(%rax,%rax,1)
mov    0x10(%rcx),%rcx
add    $0x1,%rcx
mov    0x0(%r13,%rsi,8),%rdi
mov    %rcx,0x8(%rdi)
mov    0x10(%rdi),%rcx
add    $0x1,%rcx
mov    0x8(%r13,%rsi,8),%rdi
mov    %rcx,0x8(%rdi)
mov    0x10(%rdi),%rcx
add    $0x1,%rcx
mov    0x10(%r13,%rsi,8),%rdi
mov    %rcx,0x8(%rdi)
mov    0x10(%rdi),%rdi
add    $0x1,%rdi
mov    0x18(%r13,%rsi,8),%rcx
mov    %rdi,0x8(%rcx)
lea    (%rdx,%rsi,1),%rdi
add    $0x4,%rdi
add    $0x4,%rsi
cmp    $0x2,%rdi
jne    13f0 <residue_idx+0x280>
test   %rax,%rax
je     1479 <residue_idx+0x309>
lea    0x0(,%rsi,8),%rdx
add    %r13,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    0x10(%rcx),%rdi
add    $0x1,%rdi
mov    (%rdx,%rsi,8),%rcx
mov    %rdi,0x8(%rcx)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1460 <residue_idx+0x2f0>
mov    0x8(%r13),%rax
movq   $0x1,0x8(%rax)
mov    %rbx,(%r12)
mov    (%rsp),%rdi
mov    $0x1,%esi
mov    %r14,%rdx
xor    %ecx,%ecx
mov    $0xc,%r8d
call   1060 <free_cmatrix@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r14,%rdx
call   1040 <free_lvector@plt>
mov    %r13,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [12 x i8] c"%3s%c%4ld%c\00"
define i64** @residue_idx(i64 %0, i64* nocapture %1, i8** %2, i8* nocapture %3, i8** nocapture %4, i64* nocapture writeonly %5) {
%7 = tail call i8** @cmatrix(i32 1, i64 %0, i32 0, i32 12)
%8 = tail call i64* @lvector(i32 1, i64 %0)
%9 = icmp slt i64 %0, 1
br i1 %9, label %10, label %12
10: ; preds = %6
%11 = getelementptr inbounds i64, i64* %8, i64 %0
store i64 1, i64* %11
br label %86
12: ; preds = %6
%13 = icmp eq i8** %2, null
br label %16
14: ; preds = %23
%15 = icmp sgt i64 %0, 1
br i1 %15, label %36, label %48
16: ; preds = %12, %23
%17 = phi i64 [ 1, %12 ], [ %34, %23 ]
br i1 %13, label %23, label %18
18: ; preds = %16
%19 = getelementptr inbounds i8*, i8** %2, i64 %17
%20 = load i8*, i8** %19
%21 = getelementptr inbounds i8, i8* %20, i64 2
%22 = load i8, i8* %21
br label %23
23: ; preds = %16, %18
%24 = phi i8 [ %22, %18 ], [ 32, %16 ]
%25 = getelementptr inbounds i8*, i8** %7, i64 %17
%26 = load i8*, i8** %25
%27 = getelementptr inbounds i8*, i8** %4, i64 %17
%28 = load i8*, i8** %27
%29 = getelementptr inbounds i8, i8* %3, i64 %17
%30 = load i8, i8* %29
%31 = getelementptr inbounds i64, i64* %1, i64 %17
%32 = load i64, i64* %31
%33 = tail call i32 @sprintf(i8* dereferenceable(1) %26, i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), i8* %28, i8 signext %30, i64 %32, i8 signext %24)
%34 = add nuw i64 %17, 1
%35 = icmp eq i64 %17, %0
br i1 %35, label %14, label %16
36: ; preds = %14, %36
%37 = phi i64 [ %38, %36 ], [ 1, %14 ]
%38 = add nuw nsw i64 %37, 1
%39 = getelementptr inbounds i8*, i8** %7, i64 %38
%40 = load i8*, i8** %39
%41 = getelementptr inbounds i8*, i8** %7, i64 %37
%42 = load i8*, i8** %41
%43 = tail call i64 @strcmp(i8* %40, i8* %42)
%44 = icmp ne i64 %43, 0
%45 = zext i1 %44 to i64
%46 = getelementptr inbounds i64, i64* %8, i64 %37
store i64 %45, i64* %46
%47 = icmp eq i64 %38, %0
br i1 %47, label %48, label %36
48: ; preds = %36, %14
%49 = getelementptr inbounds i64, i64* %8, i64 %0
store i64 1, i64* %49
br i1 %9, label %86, label %50
50: ; preds = %48
%51 = add i64 %0, -1
%52 = and i64 %0, 3
%53 = icmp ult i64 %51, 3
br i1 %53, label %88, label %54
54: ; preds = %50
%55 = and i64 %0, -4
br label %56
56: ; preds = %56, %54
%57 = phi i64 [ 1, %54 ], [ %83, %56 ]
%58 = phi i64 [ 0, %54 ], [ %82, %56 ]
%59 = phi i64 [ 0, %54 ], [ %84, %56 ]
%60 = getelementptr inbounds i64, i64* %8, i64 %57
%61 = load i64, i64* %60
%62 = icmp ne i64 %61, 0
%63 = zext i1 %62 to i64
%64 = add nuw nsw i64 %58, %63
%65 = add nuw nsw i64 %57, 1
%66 = getelementptr inbounds i64, i64* %8, i64 %65
%67 = load i64, i64* %66
%68 = icmp ne i64 %67, 0
%69 = zext i1 %68 to i64
%70 = add nuw nsw i64 %64, %69
%71 = add nuw nsw i64 %57, 2
%72 = getelementptr inbounds i64, i64* %8, i64 %71
%73 = load i64, i64* %72
%74 = icmp ne i64 %73, 0
%75 = zext i1 %74 to i64
%76 = add nuw nsw i64 %70, %75
%77 = add nuw i64 %57, 3
%78 = getelementptr inbounds i64, i64* %8, i64 %77
%79 = load i64, i64* %78
%80 = icmp ne i64 %79, 0
%81 = zext i1 %80 to i64
%82 = add nuw nsw i64 %76, %81
%83 = add nuw i64 %57, 4
%84 = add i64 %59, 4
%85 = icmp eq i64 %84, %55
br i1 %85, label %88, label %56
86: ; preds = %10, %48
%87 = tail call i64** @lmatrix(i32 1, i64 0, i32 1, i32 2)
br label %218
88: ; preds = %56, %50
%89 = phi i64 [ undef, %50 ], [ %82, %56 ]
%90 = phi i64 [ 1, %50 ], [ %83, %56 ]
%91 = phi i64 [ 0, %50 ], [ %82, %56 ]
%92 = icmp eq i64 %52, 0
br i1 %92, label %105, label %93
93: ; preds = %88, %93
%94 = phi i64 [ %102, %93 ], [ %90, %88 ]
%95 = phi i64 [ %101, %93 ], [ %91, %88 ]
%96 = phi i64 [ %103, %93 ], [ 0, %88 ]
%97 = getelementptr inbounds i64, i64* %8, i64 %94
%98 = load i64, i64* %97
%99 = icmp ne i64 %98, 0
%100 = zext i1 %99 to i64
%101 = add nuw nsw i64 %95, %100
%102 = add nuw i64 %94, 1
%103 = add i64 %96, 1
%104 = icmp eq i64 %103, %52
br i1 %104, label %105, label %93
105: ; preds = %93, %88
%106 = phi i64 [ %89, %88 ], [ %101, %93 ]
%107 = tail call i64** @lmatrix(i32 1, i64 %106, i32 1, i32 2)
br i1 %9, label %218, label %108
108: ; preds = %105
%109 = and i64 %0, 1
%110 = icmp eq i64 %51, 0
br i1 %110, label %113, label %111
111: ; preds = %108
%112 = and i64 %0, -2
br label %139
113: ; preds = %162, %108
%114 = phi i64 [ undef, %108 ], [ %163, %162 ]
%115 = phi i64 [ 1, %108 ], [ %164, %162 ]
%116 = phi i64 [ 0, %108 ], [ %163, %162 ]
%117 = icmp eq i64 %109, 0
br i1 %117, label %127, label %118
118: ; preds = %113
%119 = getelementptr inbounds i64, i64* %8, i64 %115
%120 = load i64, i64* %119
%121 = icmp eq i64 %120, 0
br i1 %121, label %127, label %122
122: ; preds = %118
%123 = add nsw i64 %116, 1
%124 = getelementptr inbounds i64*, i64** %107, i64 %123
%125 = load i64*, i64** %124
%126 = getelementptr inbounds i64, i64* %125, i64 2
store i64 %115, i64* %126
br label %127
127: ; preds = %118, %122, %113
%128 = phi i64 [ %114, %113 ], [ %123, %122 ], [ %116, %118 ]
%129 = icmp slt i64 %128, 2
br i1 %129, label %218, label %130
130: ; preds = %127
%131 = getelementptr inbounds i64*, i64** %107, i64 1
%132 = load i64*, i64** %131
%133 = add i64 %128, -1
%134 = add i64 %128, -2
%135 = and i64 %133, 3
%136 = icmp ult i64 %134, 3
br i1 %136, label %201, label %137
137: ; preds = %130
%138 = and i64 %133, -4
br label %167
139: ; preds = %162, %111
%140 = phi i64 [ 1, %111 ], [ %164, %162 ]
%141 = phi i64 [ 0, %111 ], [ %163, %162 ]
%142 = phi i64 [ 0, %111 ], [ %165, %162 ]
%143 = getelementptr inbounds i64, i64* %8, i64 %140
%144 = load i64, i64* %143
%145 = icmp eq i64 %144, 0
br i1 %145, label %151, label %146
146: ; preds = %139
%147 = add nsw i64 %141, 1
%148 = getelementptr inbounds i64*, i64** %107, i64 %147
%149 = load i64*, i64** %148
%150 = getelementptr inbounds i64, i64* %149, i64 2
store i64 %140, i64* %150
br label %151
151: ; preds = %139, %146
%152 = phi i64 [ %147, %146 ], [ %141, %139 ]
%153 = add nuw i64 %140, 1
%154 = getelementptr inbounds i64, i64* %8, i64 %153
%155 = load i64, i64* %154
%156 = icmp eq i64 %155, 0
br i1 %156, label %162, label %157
157: ; preds = %151
%158 = add nsw i64 %152, 1
%159 = getelementptr inbounds i64*, i64** %107, i64 %158
%160 = load i64*, i64** %159
%161 = getelementptr inbounds i64, i64* %160, i64 2
store i64 %153, i64* %161
br label %162
162: ; preds = %157, %151
%163 = phi i64 [ %158, %157 ], [ %152, %151 ]
%164 = add nuw i64 %140, 2
%165 = add i64 %142, 2
%166 = icmp eq i64 %165, %112
br i1 %166, label %113, label %139
167: ; preds = %167, %137
%168 = phi i64* [ %132, %137 ], [ %196, %167 ]
%169 = phi i64 [ 2, %137 ], [ %198, %167 ]
%170 = phi i64 [ 0, %137 ], [ %199, %167 ]
%171 = getelementptr inbounds i64, i64* %168, i64 2
%172 = load i64, i64* %171
%173 = add nsw i64 %172, 1
%174 = getelementptr inbounds i64*, i64** %107, i64 %169
%175 = load i64*, i64** %174
%176 = getelementptr inbounds i64, i64* %175, i64 1
store i64 %173, i64* %176
%177 = or i64 %169, 1
%178 = getelementptr inbounds i64, i64* %175, i64 2
%179 = load i64, i64* %178
%180 = add nsw i64 %179, 1
%181 = getelementptr inbounds i64*, i64** %107, i64 %177
%182 = load i64*, i64** %181
%183 = getelementptr inbounds i64, i64* %182, i64 1
store i64 %180, i64* %183
%184 = add nuw i64 %169, 2
%185 = getelementptr inbounds i64, i64* %182, i64 2
%186 = load i64, i64* %185
%187 = add nsw i64 %186, 1
%188 = getelementptr inbounds i64*, i64** %107, i64 %184
%189 = load i64*, i64** %188
%190 = getelementptr inbounds i64, i64* %189, i64 1
store i64 %187, i64* %190
%191 = add nuw i64 %169, 3
%192 = getelementptr inbounds i64, i64* %189, i64 2
%193 = load i64, i64* %192
%194 = add nsw i64 %193, 1
%195 = getelementptr inbounds i64*, i64** %107, i64 %191
%196 = load i64*, i64** %195
%197 = getelementptr inbounds i64, i64* %196, i64 1
store i64 %194, i64* %197
%198 = add nuw i64 %169, 4
%199 = add i64 %170, 4
%200 = icmp eq i64 %199, %138
br i1 %200, label %201, label %167
201: ; preds = %167, %130
%202 = phi i64* [ %132, %130 ], [ %196, %167 ]
%203 = phi i64 [ 2, %130 ], [ %198, %167 ]
%204 = icmp eq i64 %135, 0
br i1 %204, label %218, label %205
205: ; preds = %201, %205
%206 = phi i64* [ %213, %205 ], [ %202, %201 ]
%207 = phi i64 [ %215, %205 ], [ %203, %201 ]
%208 = phi i64 [ %216, %205 ], [ 0, %201 ]
%209 = getelementptr inbounds i64, i64* %206, i64 2
%210 = load i64, i64* %209
%211 = add nsw i64 %210, 1
%212 = getelementptr inbounds i64*, i64** %107, i64 %207
%213 = load i64*, i64** %212
%214 = getelementptr inbounds i64, i64* %213, i64 1
store i64 %211, i64* %214
%215 = add nuw i64 %207, 1
%216 = add i64 %208, 1
%217 = icmp eq i64 %216, %135
br i1 %217, label %218, label %205
218: ; preds = %201, %205, %86, %105, %127
%219 = phi i64 [ %128, %127 ], [ 0, %105 ], [ 0, %86 ], [ %128, %205 ], [ %128, %201 ]
%220 = phi i64** [ %107, %127 ], [ %107, %105 ], [ %87, %86 ], [ %107, %205 ], [ %107, %201 ]
%221 = getelementptr inbounds i64*, i64** %220, i64 1
%222 = load i64*, i64** %221
%223 = getelementptr inbounds i64, i64* %222, i64 1
store i64 1, i64* %223
store i64 %219, i64* %5
%224 = tail call i32 @free_cmatrix(i8** %7, i32 1, i64 %0, i32 0, i32 12)
%225 = tail call i32 @free_lvector(i64* %8, i32 1, i64 %0)
ret i64** %220
}