#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*/ eval(int *, int, int *, int *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(int *);
int *make(int, int);
int *malloc(int);
int random();
int /*<<< orphan*/ show(int /*<<< orphan*/, int, int, int *);
int /*<<< orphan*/ stdout;
void path_mutate(int *lhs, int *rhs, int mcount, int mwidth, int *individuum) {
  int *lres = make(mwidth, mwidth);
  int *rres = make(mwidth, mwidth);
  eval(lhs, mwidth, individuum, lres);
  eval(rhs, mwidth, individuum, rres);
  int top = 0;
  int *rows = malloc(mwidth * mwidth * sizeof(int));
  int *cols = malloc(mwidth * mwidth * sizeof(int));
  for (int row = 0; row < mwidth; row++) {
    for (int col = 0; col < mwidth; col++) {
      int special = (row == 0) && (col == mwidth - 1);
      int l = lres[row * mwidth + col];
      int r = rres[row * mwidth + col];
      int ok = special ? (l > r) : (l >= r);
      if (!ok) {
        rows[top] = row;
        cols[top] = col;
        top++;
      }
    }
  }
  if (0 == top) {
    fprintf(stdout, "what");
    show(stdout, mcount, mwidth, individuum);
    return;
  }
  int i = random() % top;
  int l = rows[i];
  int r = cols[i];
  free(rows);
  free(cols);
  free(lres);
  free(rres);
  for (int i = 0; lhs[i] >= 0; i++) {
    int c = lhs[i];
    int goal = lhs[i + 1] < 0 ? r : 1 + random() % (mwidth - 2);
    int *pos = individuum + c * mwidth * mwidth + l * mwidth + goal;
    int new = *pos + 1;
    if (new < 1)
      new = 1;
    *pos = new;
    l = goal;
  }
}


x86 assembly (clang, -O0):
<path_mutate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x18(%rbp),%esi
call   1090 <make@plt>
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x18(%rbp),%esi
call   1090 <make@plt>
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
call   1080 <eval@plt>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1080 <eval@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x18(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x18(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1327 <path_mutate+0x1b7>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1314 <path_mutate+0x1a4>
xor    %eax,%eax
cmpl   $0x0,-0x4c(%rbp)
mov    %al,-0x85(%rbp)
jne    1256 <path_mutate+0xe6>
mov    -0x50(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x85(%rbp)
mov    -0x85(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x54(%rbp)
je     12b5 <path_mutate+0x145>
mov    -0x58(%rbp),%eax
cmp    -0x5c(%rbp),%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x8c(%rbp)
jmp    12c9 <path_mutate+0x159>
mov    -0x58(%rbp),%eax
cmp    -0x5c(%rbp),%eax
setge  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x0,-0x60(%rbp)
jne    1301 <path_mutate+0x191>
mov    -0x4c(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%edx
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1306 <path_mutate+0x196>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1224 <path_mutate+0xb4>
jmp    1319 <path_mutate+0x1a9>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1211 <path_mutate+0xa1>
xor    %eax,%eax
cmp    -0x34(%rbp),%eax
jne    1364 <path_mutate+0x1f4>
mov    0x2ca7(%rip),%rax
mov    (%rax),%edi
lea    0xcbe(%rip),%rsi
call   1050 <fprintf@plt>
mov    0x2c92(%rip),%rax
mov    (%rax),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1040 <show@plt>
jmp    14a1 <path_mutate+0x331>
mov    $0x0,%al
call   1060 <random@plt>
cltd
idivl  -0x34(%rbp)
mov    %edx,-0x64(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x70(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     14a1 <path_mutate+0x331>
mov    -0x8(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    13fe <path_mutate+0x28e>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    1419 <path_mutate+0x2a9>
mov    $0x0,%al
call   1060 <random@plt>
mov    -0x18(%rbp),%ecx
sub    $0x2,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x18(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x68(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
cmpl   $0x1,-0x84(%rbp)
jge    1481 <path_mutate+0x311>
movl   $0x1,-0x84(%rbp)
mov    -0x84(%rbp),%ecx
mov    -0x80(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x78(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    13b9 <path_mutate+0x249>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<path_mutate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8,%r12
mov    %ecx,%ebp
mov    %edx,(%rsp)
mov    %rsi,%r14
mov    %rdi,%r13
mov    %ecx,%edi
mov    %ecx,%esi
call   1090 <make@plt>
mov    %rax,%rbx
mov    %ebp,%edi
mov    %ebp,%esi
call   1090 <make@plt>
mov    %rax,%r15
mov    %r13,%rdi
mov    %ebp,%esi
mov    %r12,%rdx
mov    %rbx,0x18(%rsp)
mov    %rbx,%rcx
call   1080 <eval@plt>
mov    %r14,%rdi
mov    %ebp,%esi
mov    %r12,0x8(%rsp)
mov    %r12,%rdx
mov    %r15,%rbx
mov    %r15,%rcx
call   1080 <eval@plt>
mov    %ebp,%eax
imul   %eax,%eax
mov    %rax,0x20(%rsp)
lea    0x0(,%rax,4),%r12d
mov    %r12d,%edi
call   1070 <malloc@plt>
mov    %rax,%r15
mov    %r12d,%edi
call   1070 <malloc@plt>
mov    %rbp,%r10
test   %r10d,%r10d
jle    1348 <path_mutate+0x1d8>
mov    %rax,%r12
lea    -0x1(%r10),%r9d
mov    %r10d,%ecx
lea    0x0(,%rcx,4),%r8
xor    %esi,%esi
mov    %rbx,0x10(%rsp)
mov    %rbx,%rdi
mov    0x18(%rsp),%r11
mov    %r11,%rbx
xor    %r14d,%r14d
jmp    123f <path_mutate+0xcf>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
add    %r8,%rbx
add    %r8,%rdi
cmp    %rcx,%rsi
je     1286 <path_mutate+0x116>
xor    %edx,%edx
jmp    1268 <path_mutate+0xf8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %r14d,%r14
mov    %esi,(%r15,%r14,4)
mov    %edx,(%r12,%r14,4)
add    $0x1,%r14d
add    $0x1,%rdx
cmp    %rdx,%rcx
je     1230 <path_mutate+0xc0>
mov    (%rbx,%rdx,4),%ebp
mov    (%rdi,%rdx,4),%eax
test   %rsi,%rsi
jne    1280 <path_mutate+0x110>
cmp    %rdx,%r9
jne    1280 <path_mutate+0x110>
cmp    %eax,%ebp
jle    1250 <path_mutate+0xe0>
jmp    125f <path_mutate+0xef>
xchg   %ax,%ax
cmp    %eax,%ebp
jl     1250 <path_mutate+0xe0>
jmp    125f <path_mutate+0xef>
test   %r14d,%r14d
je     1348 <path_mutate+0x1d8>
mov    %r11,%rbp
xor    %eax,%eax
mov    %r10,(%rsp)
call   1060 <random@plt>
cltd
idiv   %r14d
movslq %edx,%rax
mov    (%r15,%rax,4),%ebx
mov    (%r12,%rax,4),%r14d
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    (%rsp),%rdi
mov    0x0(%r13),%ebp
test   %ebp,%ebp
mov    0x8(%rsp),%r15
js     137f <path_mutate+0x20f>
lea    -0x2(%rdi),%r12d
add    $0x4,%r13
jmp    132a <path_mutate+0x1ba>
nopl   (%rax)
imul   0x20(%rsp),%ebp
movslq %ebp,%rax
lea    (%r15,%rax,4),%rax
imul   %edi,%ebx
movslq %ebx,%rcx
lea    (%rax,%rcx,4),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,4),%esi
test   %esi,%esi
mov    $0x0,%ebp
cmovs  %ebp,%esi
add    $0x1,%esi
mov    %esi,(%rax,%rcx,4)
mov    0x0(%r13),%ebp
add    $0x4,%r13
mov    %edx,%ebx
test   %ebp,%ebp
js     137f <path_mutate+0x20f>
cmpl   $0x0,0x0(%r13)
mov    %r14d,%edx
js     12f0 <path_mutate+0x180>
xor    %eax,%eax
call   1060 <random@plt>
mov    (%rsp),%rdi
cltd
idiv   %r12d
add    $0x1,%edx
jmp    12f0 <path_mutate+0x180>
mov    0x2c91(%rip),%rbx
mov    (%rbx),%edi
lea    0xca8(%rip),%rsi
mov    %r10,%rbp
call   1050 <fprintf@plt>
mov    (%rbx),%edi
mov    (%rsp),%esi
mov    %ebp,%edx
mov    0x8(%rsp),%rcx
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <show@plt>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@stdout = global i32 0
@.str = [5 x i8] c"what\00"
define void @path_mutate(i32* %0, i32* %1, i32 %2, i32 %3, i32* %4) {
%6 = tail call i32* @make(i32 %3, i32 %3)
%7 = tail call i32* @make(i32 %3, i32 %3)
%8 = tail call i32 @eval(i32* %0, i32 %3, i32* %4, i32* %6)
%9 = tail call i32 @eval(i32* %1, i32 %3, i32* %4, i32* %7)
%10 = mul i32 %3, %3
%11 = shl i32 %10, 2
%12 = tail call i32* @malloc(i32 %11)
%13 = tail call i32* @malloc(i32 %11)
%14 = icmp sgt i32 %3, 0
br i1 %14, label %15, label %55
15: ; preds = %5
%16 = add nsw i32 %3, -1
%17 = zext i32 %16 to i64
%18 = zext i32 %3 to i64
%19 = zext i32 %3 to i64
br label %20
20: ; preds = %28, %15
%21 = phi i64 [ 0, %15 ], [ %29, %28 ]
%22 = phi i32 [ 0, %15 ], [ %52, %28 ]
%23 = icmp eq i64 %21, 0
%24 = mul nsw i64 %21, %18
%25 = trunc i64 %21 to i32
br label %31
26: ; preds = %28
%27 = icmp eq i32 %52, 0
br i1 %27, label %55, label %60
28: ; preds = %51
%29 = add nuw nsw i64 %21, 1
%30 = icmp eq i64 %29, %19
br i1 %30, label %26, label %20
31: ; preds = %20, %51
%32 = phi i64 [ 0, %20 ], [ %53, %51 ]
%33 = phi i32 [ %22, %20 ], [ %52, %51 ]
%34 = icmp eq i64 %32, %17
%35 = select i1 %23, i1 %34, i1 false
%36 = add nuw nsw i64 %32, %24
%37 = getelementptr inbounds i32, i32* %6, i64 %36
%38 = load i32, i32* %37
%39 = getelementptr inbounds i32, i32* %7, i64 %36
%40 = load i32, i32* %39
br i1 %35, label %41, label %43
41: ; preds = %31
%42 = icmp sgt i32 %38, %40
br i1 %42, label %51, label %45
43: ; preds = %31
%44 = icmp slt i32 %38, %40
br i1 %44, label %45, label %51
45: ; preds = %41, %43
%46 = sext i32 %33 to i64
%47 = getelementptr inbounds i32, i32* %12, i64 %46
store i32 %25, i32* %47
%48 = getelementptr inbounds i32, i32* %13, i64 %46
%49 = trunc i64 %32 to i32
store i32 %49, i32* %48
%50 = add nsw i32 %33, 1
br label %51
51: ; preds = %41, %45, %43
%52 = phi i32 [ %33, %43 ], [ %50, %45 ], [ %33, %41 ]
%53 = add nuw nsw i64 %32, 1
%54 = icmp eq i64 %53, %19
br i1 %54, label %28, label %31
55: ; preds = %5, %26
%56 = load i32, i32* @stdout
%57 = tail call i32 @fprintf(i32 %56, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%58 = load i32, i32* @stdout
%59 = tail call i32 @show(i32 %58, i32 %2, i32 %3, i32* %4)
br label %104
60: ; preds = %26
%61 = tail call i32 (...) @random()
%62 = srem i32 %61, %52
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %12, i64 %63
%65 = load i32, i32* %64
%66 = getelementptr inbounds i32, i32* %13, i64 %63
%67 = load i32, i32* %66
%68 = tail call i32 @free(i32* %12)
%69 = tail call i32 @free(i32* %13)
%70 = tail call i32 @free(i32* %6)
%71 = tail call i32 @free(i32* %7)
%72 = load i32, i32* %0
%73 = icmp sgt i32 %72, -1
br i1 %73, label %74, label %104
74: ; preds = %60
%75 = add nsw i32 %3, -2
br label %76
76: ; preds = %74, %88
%77 = phi i64 [ 0, %74 ], [ %80, %88 ]
%78 = phi i32 [ %72, %74 ], [ %102, %88 ]
%79 = phi i32 [ %65, %74 ], [ %89, %88 ]
%80 = add nuw nsw i64 %77, 1
%81 = getelementptr inbounds i32, i32* %0, i64 %80
%82 = load i32, i32* %81
%83 = icmp slt i32 %82, 0
br i1 %83, label %88, label %84
84: ; preds = %76
%85 = tail call i32 (...) @random()
%86 = srem i32 %85, %75
%87 = add nsw i32 %86, 1
br label %88
88: ; preds = %76, %84
%89 = phi i32 [ %87, %84 ], [ %67, %76 ]
%90 = mul i32 %10, %78
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i32, i32* %4, i64 %91
%93 = mul nsw i32 %79, %3
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %92, i64 %94
%96 = sext i32 %89 to i64
%97 = getelementptr inbounds i32, i32* %95, i64 %96
%98 = load i32, i32* %97
%99 = icmp sgt i32 %98, 0
%100 = select i1 %99, i32 %98, i32 0
%101 = add nuw nsw i32 %100, 1
store i32 %101, i32* %97
%102 = load i32, i32* %81
%103 = icmp sgt i32 %102, -1
br i1 %103, label %76, label %104
104: ; preds = %88, %60, %55
ret void
}