void crash_me(int num1, int num2, char *in, char *out) {
  int i, j;
  for (j = 0; j < num1; j++)
    for (i = 0; i < num2; i++)
      *out++ = *in++;
}


x86 assembly (clang, -O0):
<crash_me>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    117b <crash_me+0x7b>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1168 <crash_me+0x68>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112c <crash_me+0x2c>
jmp    116d <crash_me+0x6d>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1119 <crash_me+0x19>
pop    %rbp
ret

x86 assembly (clang, -O2):
<crash_me>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
jle    12e8 <crash_me+0x1e8>
lea    -0x1(%rsi),%r8d
lea    0x1(%r8),%r15
mov    %r15,%r9
and    $0xffffffffffffffe0,%r9
lea    -0x20(%r9),%r11
mov    %r11,-0x8(%rsp)
shr    $0x5,%r11
add    $0x1,%r11
mov    %r11d,%r12d
and    $0x3,%r12d
and    $0xfffffffffffffffc,%r11
mov    %r12,-0x10(%rsp)
shl    $0x5,%r12
xor    %r14d,%r14d
jmp    115d <crash_me+0x5d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14d
cmp    %edi,%r14d
je     12e8 <crash_me+0x1e8>
test   %esi,%esi
jle    1150 <crash_me+0x50>
xor    %r13d,%r13d
cmp    $0x1f,%r8d
jb     1250 <crash_me+0x150>
lea    (%rdx,%r15,1),%rax
cmp    %rax,%rcx
jae    1184 <crash_me+0x84>
lea    (%rcx,%r15,1),%rax
cmp    %rax,%rdx
jb     1250 <crash_me+0x150>
cmpq   $0x60,-0x8(%rsp)
jae    1190 <crash_me+0x90>
xor    %ebx,%ebx
jmp    11f8 <crash_me+0xf8>
mov    %r11,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rdx,%rbx,1),%xmm0
movups 0x10(%rdx,%rbx,1),%xmm1
movups %xmm0,(%rcx,%rbx,1)
movups %xmm1,0x10(%rcx,%rbx,1)
movups 0x20(%rdx,%rbx,1),%xmm0
movups 0x30(%rdx,%rbx,1),%xmm1
movups %xmm0,0x20(%rcx,%rbx,1)
movups %xmm1,0x30(%rcx,%rbx,1)
movups 0x40(%rdx,%rbx,1),%xmm0
movups 0x50(%rdx,%rbx,1),%xmm1
movups %xmm0,0x40(%rcx,%rbx,1)
movups %xmm1,0x50(%rcx,%rbx,1)
movups 0x60(%rdx,%rbx,1),%xmm0
movups 0x70(%rdx,%rbx,1),%xmm1
movups %xmm0,0x60(%rcx,%rbx,1)
movups %xmm1,0x70(%rcx,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rbp
jne    11a0 <crash_me+0xa0>
cmpq   $0x0,-0x10(%rsp)
je     123c <crash_me+0x13c>
lea    (%rdx,%rbx,1),%rbp
add    $0x10,%rbp
add    %rcx,%rbx
add    $0x10,%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x10(%rbp,%rax,1),%xmm0
movups 0x0(%rbp,%rax,1),%xmm1
movups %xmm0,-0x10(%rbx,%rax,1)
movups %xmm1,(%rbx,%rax,1)
add    $0x20,%rax
cmp    %rax,%r12
jne    1220 <crash_me+0x120>
add    %r9,%rcx
add    %r9,%rdx
mov    %r9d,%r13d
cmp    %r9,%r15
je     1150 <crash_me+0x50>
xchg   %ax,%ax
mov    %esi,%ebx
sub    %r13d,%ebx
mov    %r13d,%ebp
not    %ebp
add    %esi,%ebp
and    $0x7,%ebx
je     1289 <crash_me+0x189>
neg    %ebx
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
movzbl (%rdx),%eax
add    $0x1,%rdx
mov    %al,(%rcx)
add    $0x1,%rcx
add    $0xffffffffffffffff,%r10
cmp    %r10d,%ebx
jne    1270 <crash_me+0x170>
sub    %r10d,%r13d
cmp    $0x7,%ebp
jb     1150 <crash_me+0x50>
mov    %esi,%ebx
sub    %r13d,%ebx
nopw   0x0(%rax,%rax,1)
movzbl (%rdx),%eax
mov    %al,(%rcx)
movzbl 0x1(%rdx),%eax
mov    %al,0x1(%rcx)
movzbl 0x2(%rdx),%eax
mov    %al,0x2(%rcx)
movzbl 0x3(%rdx),%eax
mov    %al,0x3(%rcx)
movzbl 0x4(%rdx),%eax
mov    %al,0x4(%rcx)
movzbl 0x5(%rdx),%eax
mov    %al,0x5(%rcx)
movzbl 0x6(%rdx),%eax
mov    %al,0x6(%rcx)
movzbl 0x7(%rdx),%eax
add    $0x8,%rdx
mov    %al,0x7(%rcx)
add    $0x8,%rcx
add    $0xfffffff8,%ebx
jne    12a0 <crash_me+0x1a0>
jmp    1150 <crash_me+0x50>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @crash_me(i32 %0, i32 %1, i8* %2, i8* %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
store i32 %0, i32* %5
store i32 %1, i32* %6
store i8* %2, i8** %7
store i8* %3, i8** %8
store i32 0, i32* %10
br label %11
11: ; preds = %30, %4
%12 = load i32, i32* %10
%13 = load i32, i32* %5
%14 = icmp slt i32 %12, %13
br i1 %14, label %15, label %33
15: ; preds = %11
store i32 0, i32* %9
br label %16
16: ; preds = %26, %15
%17 = load i32, i32* %9
%18 = load i32, i32* %6
%19 = icmp slt i32 %17, %18
br i1 %19, label %20, label %29
20: ; preds = %16
%21 = load i8*, i8** %7
%22 = getelementptr inbounds i8, i8* %21, i32 1
store i8* %22, i8** %7
%23 = load i8, i8* %21
%24 = load i8*, i8** %8
%25 = getelementptr inbounds i8, i8* %24, i32 1
store i8* %25, i8** %8
store i8 %23, i8* %24
br label %26
26: ; preds = %20
%27 = load i32, i32* %9
%28 = add nsw i32 %27, 1
store i32 %28, i32* %9
br label %16
29: ; preds = %16
br label %30
30: ; preds = %29
%31 = load i32, i32* %10
%32 = add nsw i32 %31, 1
store i32 %32, i32* %10
br label %11
33: ; preds = %11
ret void
}

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