void addRow(int *nrRows, int *nrCapRows, int *nrNz, int *nrCapNz, int **nrStart,
            int **nrIdx, double **nrCoef, char **nrSense, double **nrRhs,
            int nz, const int idx[], const double coef[], char sense,
            double rhs, const char *rowName, char ***rowNames, int *nrLines,
            int *nrCap, int *nrChars, int *nrCharsCap) {
  if ((*nrRows) + 2 >= (*nrCapRows)) {
    (*nrCapRows) =
        ((2 * (*nrCapRows)) > ((*nrCapRows) + 32) ? (2 * (*nrCapRows))
                                                  : ((*nrCapRows) + 32));
    (*nrStart) = xrealloc((*nrStart), sizeof(int) * ((*nrCapRows) + 1));
    (*nrSense) = xrealloc((*nrSense), sizeof(char) * ((*nrCapRows)));
    (*nrRhs) = xrealloc((*nrRhs), sizeof(double) * (*nrCapRows));
  }
  if (((*nrNz) + nz) >= (*nrCapNz)) {
    (*nrCapNz) = (((*nrCapNz) * 2) > (((*nrNz) + nz)) ? ((*nrCapNz) * 2)
                                                      : (((*nrNz) + nz)));
    (*nrIdx) = xrealloc((*nrIdx), sizeof(int) * (*nrCapNz));
    (*nrCoef) = xrealloc((*nrCoef), sizeof(double) * (*nrCapNz));
  }
  int *pidx = (*nrIdx) + (*nrNz);
  double *pcoef = (*nrCoef) + (*nrNz);
  memcpy(pidx, idx, sizeof(int) * nz);
  memcpy(pcoef, coef, sizeof(double) * nz);
  (*nrSense)[(*nrRows)] = sense;
  (*nrRhs)[(*nrRows)] = rhs;
  (*nrStart)[(*nrRows) + 1] = (*nrStart)[(*nrRows)] + nz;
  (*nrNz) += nz;
  addName(rowNames, nrLines, nrChars, nrCap, nrCharsCap, rowName);
  ++(*nrRows);
}


x86 assembly (clang, -O0):
<addRow>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%al
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
add    $0x2,%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jl     124a <addRow+0x11a>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x20,%ecx
cmp    %ecx,%eax
jle    11c7 <addRow+0x97>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11d3 <addRow+0xa3>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
add    $0x20,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
movslq %eax,%rsi
shl    $0x2,%rsi
mov    $0x0,%al
call   1030 <xrealloc@plt>
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
movslq (%rax),%rsi
shl    $0x0,%rsi
mov    $0x0,%al
call   1030 <xrealloc@plt>
movslq %eax,%rcx
mov    0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
movslq (%rax),%rsi
shl    $0x3,%rsi
mov    $0x0,%al
call   1030 <xrealloc@plt>
movslq %eax,%rcx
mov    0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
add    0x28(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jl     12e5 <addRow+0x1b5>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    0x28(%rbp),%ecx
cmp    %ecx,%eax
jle    128a <addRow+0x15a>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1296 <addRow+0x166>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
add    0x28(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
mov    -0x20(%rbp),%rax
movslq (%rax),%rsi
shl    $0x2,%rsi
mov    $0x0,%al
call   1030 <xrealloc@plt>
movslq %eax,%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x20(%rbp),%rax
movslq (%rax),%rsi
shl    $0x3,%rsi
mov    $0x0,%al
call   1030 <xrealloc@plt>
movslq %eax,%rcx
mov    0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
movslq (%rcx),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
movslq (%rcx),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rdi
mov    0x30(%rbp),%rsi
movslq 0x28(%rbp),%rdx
shl    $0x2,%rdx
call   1040 <memcpy@plt>
mov    -0x48(%rbp),%rdi
mov    0x38(%rbp),%rsi
movslq 0x28(%rbp),%rdx
shl    $0x3,%rdx
call   1040 <memcpy@plt>
mov    0x40(%rbp),%dl
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
mov    %dl,(%rax,%rcx,1)
movsd  -0x38(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%edx
add    0x28(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%ecx
mov    -0x18(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    0x50(%rbp),%rdi
mov    0x58(%rbp),%rsi
mov    0x68(%rbp),%rdx
mov    0x60(%rbp),%rcx
mov    0x70(%rbp),%r8
mov    0x48(%rbp),%r9
mov    $0x0,%al
call   1050 <addName@plt>
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<addRow>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
movsd  %xmm0,0x10(%rsp)
mov    %r9,0x8(%rsp)
mov    %r8,%r14
mov    %rcx,%r13
mov    %rdx,%r12
mov    %rdi,%r15
mov    0x68(%rsp),%ebx
mov    (%rdi),%ecx
add    $0x2,%ecx
mov    (%rsi),%eax
cmp    %eax,%ecx
jl     11ca <addRow+0x9a>
mov    %rsi,%rbp
lea    (%rax,%rax,1),%ecx
add    $0x20,%eax
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %eax,(%rsi)
mov    (%r14),%rdi
cltq
lea    0x4(,%rax,4),%rsi
xor    %eax,%eax
call   1030 <xrealloc@plt>
cltq
mov    %rax,(%r14)
mov    0x58(%rsp),%rbx
mov    (%rbx),%rdi
movslq 0x0(%rbp),%rsi
xor    %eax,%eax
call   1030 <xrealloc@plt>
cltq
mov    %rax,(%rbx)
mov    0x60(%rsp),%rax
mov    (%rax),%rdi
movslq 0x0(%rbp),%rsi
shl    $0x3,%rsi
xor    %eax,%eax
call   1030 <xrealloc@plt>
mov    0x68(%rsp),%ebx
cltq
mov    0x60(%rsp),%rcx
mov    %rax,(%rcx)
mov    0x70(%rsp),%rsi
mov    0x50(%rsp),%rdi
mov    (%r12),%eax
lea    (%rax,%rbx,1),%edx
mov    0x0(%r13),%ecx
cmp    %ecx,%edx
jge    11ed <addRow+0xbd>
mov    (%rdi),%rcx
mov    0x8(%rsp),%rbp
jmp    1240 <addRow+0x110>
add    %ecx,%ecx
cmp    %edx,%ecx
cmovle %edx,%ecx
mov    %ecx,0x0(%r13)
mov    0x8(%rsp),%rbp
mov    0x0(%rbp),%rdi
movslq %ecx,%rsi
shl    $0x2,%rsi
xor    %eax,%eax
call   1030 <xrealloc@plt>
cltq
mov    %rax,0x0(%rbp)
mov    0x50(%rsp),%rax
mov    (%rax),%rdi
movslq 0x0(%r13),%rsi
shl    $0x3,%rsi
xor    %eax,%eax
call   1030 <xrealloc@plt>
mov    0x70(%rsp),%rsi
movslq %eax,%rcx
mov    0x50(%rsp),%rax
mov    %rcx,(%rax)
mov    (%r12),%eax
cltq
lea    0x0(,%rax,4),%rdi
add    0x0(%rbp),%rdi
lea    (%rcx,%rax,8),%rbp
movslq %ebx,%rbx
lea    0x0(,%rbx,4),%rdx
call   1040 <memcpy@plt>
lea    0x0(,%rbx,8),%rdx
mov    %rbp,%rdi
mov    0x78(%rsp),%rsi
call   1040 <memcpy@plt>
mov    0x58(%rsp),%rax
mov    (%rax),%rax
movslq (%r15),%rcx
mov    0x80(%rsp),%dl
mov    %dl,(%rax,%rcx,1)
mov    0x60(%rsp),%rax
mov    (%rax),%rax
movslq (%r15),%rcx
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    (%r14),%rax
mov    (%rax,%rcx,4),%edx
add    %ebx,%edx
mov    %edx,0x4(%rax,%rcx,4)
add    %ebx,(%r12)
mov    0x90(%rsp),%rdi
mov    0x98(%rsp),%rsi
mov    0xa8(%rsp),%rdx
mov    0xa0(%rsp),%rcx
mov    0xb0(%rsp),%r8
mov    0x88(%rsp),%r9
xor    %eax,%eax
call   1050 <addName@plt>
addl   $0x1,(%r15)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @addRow(i32* nocapture %0, i32* nocapture %1, i32* nocapture %2, i32* nocapture %3, i32** nocapture %4, i32** nocapture %5, double** nocapture %6, i8** nocapture %7, double** nocapture %8, i32 %9, i32* nocapture %10, double* nocapture %11, i8 signext %12, double %13, i8* %14, i8*** %15, i32* %16, i32* %17, i32* %18, i32* %19) {
%21 = load i32, i32* %0
%22 = add nsw i32 %21, 2
%23 = load i32, i32* %1
%24 = icmp slt i32 %22, %23
br i1 %24, label %50, label %25
25: ; preds = %20
%26 = shl nsw i32 %23, 1
%27 = add nsw i32 %23, 32
%28 = icmp sgt i32 %26, %27
%29 = select i1 %28, i32 %26, i32 %27
store i32 %29, i32* %1
%30 = load i32*, i32** %4
%31 = add nsw i32 %29, 1
%32 = sext i32 %31 to i64
%33 = shl nsw i64 %32, 2
%34 = tail call i32 (i32*, i64, ...) bitcast (i32 (...)* @xrealloc to i32 (i32*, i64, ...)*)(i32* %30, i64 %33)
%35 = sext i32 %34 to i64
%36 = inttoptr i64 %35 to i32*
store i32* %36, i32** %4
%37 = load i8*, i8** %7
%38 = load i32, i32* %1
%39 = sext i32 %38 to i64
%40 = tail call i32 (i8*, i64, ...) bitcast (i32 (...)* @xrealloc to i32 (i8*, i64, ...)*)(i8* %37, i64 %39)
%41 = sext i32 %40 to i64
%42 = inttoptr i64 %41 to i8*
store i8* %42, i8** %7
%43 = load double*, double** %8
%44 = load i32, i32* %1
%45 = sext i32 %44 to i64
%46 = shl nsw i64 %45, 3
%47 = tail call i32 (double*, i64, ...) bitcast (i32 (...)* @xrealloc to i32 (double*, i64, ...)*)(double* %43, i64 %46)
%48 = sext i32 %47 to i64
%49 = inttoptr i64 %48 to double*
store double* %49, double** %8
br label %50
50: ; preds = %25, %20
%51 = load i32, i32* %2
%52 = add nsw i32 %51, %9
%53 = load i32, i32* %3
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %57
55: ; preds = %50
%56 = load double*, double** %6
br label %75
57: ; preds = %50
%58 = shl nsw i32 %53, 1
%59 = icmp sgt i32 %58, %52
%60 = select i1 %59, i32 %58, i32 %52
store i32 %60, i32* %3
%61 = load i32*, i32** %5
%62 = sext i32 %60 to i64
%63 = shl nsw i64 %62, 2
%64 = tail call i32 (i32*, i64, ...) bitcast (i32 (...)* @xrealloc to i32 (i32*, i64, ...)*)(i32* %61, i64 %63)
%65 = sext i32 %64 to i64
%66 = inttoptr i64 %65 to i32*
store i32* %66, i32** %5
%67 = load double*, double** %6
%68 = load i32, i32* %3
%69 = sext i32 %68 to i64
%70 = shl nsw i64 %69, 3
%71 = tail call i32 (double*, i64, ...) bitcast (i32 (...)* @xrealloc to i32 (double*, i64, ...)*)(double* %67, i64 %70)
%72 = sext i32 %71 to i64
%73 = inttoptr i64 %72 to double*
store double* %73, double** %6
%74 = load i32, i32* %2
br label %75
75: ; preds = %55, %57
%76 = phi double* [ %73, %57 ], [ %56, %55 ]
%77 = phi i32 [ %74, %57 ], [ %51, %55 ]
%78 = load i32*, i32** %5
%79 = sext i32 %77 to i64
%80 = getelementptr inbounds i32, i32* %78, i64 %79
%81 = getelementptr inbounds double, double* %76, i64 %79
%82 = bitcast i32* %80 to i8*
%83 = bitcast i32* %10 to i8*
%84 = sext i32 %9 to i64
%85 = shl nsw i64 %84, 2
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %82, i8* align 4 %83, i64 %85, i1 false)
%86 = bitcast double* %81 to i8*
%87 = bitcast double* %11 to i8*
%88 = shl nsw i64 %84, 3
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %86, i8* align 8 %87, i64 %88, i1 false)
%89 = load i8*, i8** %7
%90 = load i32, i32* %0
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %89, i64 %91
store i8 %12, i8* %92
%93 = load double*, double** %8
%94 = load i32, i32* %0
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %93, i64 %95
store double %13, double* %96
%97 = load i32*, i32** %4
%98 = getelementptr inbounds i32, i32* %97, i64 %95
%99 = load i32, i32* %98
%100 = add nsw i32 %99, %9
%101 = add nsw i32 %94, 1
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i32, i32* %97, i64 %102
store i32 %100, i32* %103
%104 = load i32, i32* %2
%105 = add nsw i32 %104, %9
store i32 %105, i32* %2
%106 = tail call i32 (i8***, i32*, i32*, i32*, i32*, i8*, ...) bitcast (i32 (...)* @addName to i32 (i8***, i32*, i32*, i32*, i32*, i8*, ...)*)(i8*** %15, i32* %16, i32* %18, i32* %17, i32* %19, i8* %14)
%107 = load i32, i32* %0
%108 = add nsw i32 %107, 1
store i32 %108, i32* %0
ret void
}