void extract_block(const unsigned char *src, int x, int y, int w, int h,
                   unsigned char *block) {
  int i, j;
  int bw = ((w - x) < (4) ? (w - x) : (4));
  int bh = ((h - y) < (4) ? (h - y) : (4));
  int bx, by;
  const int rem[] = {0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 2, 0, 0, 1, 2, 3};
  for (i = 0; i < 4; ++i) {
    by = rem[(bh - 1) * 4 + i] + y;
    for (j = 0; j < 4; ++j) {
      bx = rem[(bw - 1) * 4 + j] + x;
      block[(i * 4 * 4) + (j * 4) + 0] = src[(by * (w * 4)) + (bx * 4) + 0];
      block[(i * 4 * 4) + (j * 4) + 1] = src[(by * (w * 4)) + (bx * 4) + 1];
      block[(i * 4 * 4) + (j * 4) + 2] = src[(by * (w * 4)) + (bx * 4) + 2];
      block[(i * 4 * 4) + (j * 4) + 3] = src[(by * (w * 4)) + (bx * 4) + 3];
    }
  }
}


x86 assembly (clang, -O0):
<extract_block>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0x14(%rbp),%eax
sub    -0xc(%rbp),%eax
cmp    $0x4,%eax
jge    1150 <extract_block+0x40>
mov    -0x14(%rbp),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    1160 <extract_block+0x50>
mov    $0x4,%eax
mov    %eax,-0x84(%rbp)
jmp    1160 <extract_block+0x50>
mov    -0x84(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
sub    -0x10(%rbp),%eax
cmp    $0x4,%eax
jge    1189 <extract_block+0x79>
mov    -0x18(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x88(%rbp)
jmp    1199 <extract_block+0x89>
mov    $0x4,%eax
mov    %eax,-0x88(%rbp)
jmp    1199 <extract_block+0x89>
mov    -0x88(%rbp),%eax
mov    %eax,-0x30(%rbp)
lea    -0x80(%rbp),%rdi
lea    0xe53(%rip),%rsi
mov    $0x40,%edx
call   1030 <memcpy@plt>
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    1326 <extract_block+0x216>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
shl    $0x2,%eax
add    -0x24(%rbp),%eax
cltq
mov    -0x80(%rbp,%rax,4),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x4,-0x28(%rbp)
jge    1313 <extract_block+0x203>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
shl    $0x2,%eax
add    -0x28(%rbp),%eax
cltq
mov    -0x80(%rbp,%rax,4),%eax
add    -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x14(%rbp),%edx
shl    $0x2,%edx
imul   %edx,%ecx
mov    -0x34(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
shl    $0x2,%ecx
mov    -0x28(%rbp),%esi
shl    $0x2,%esi
add    %esi,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x14(%rbp),%edx
shl    $0x2,%edx
imul   %edx,%ecx
mov    -0x34(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
shl    $0x2,%ecx
mov    -0x28(%rbp),%esi
shl    $0x2,%esi
add    %esi,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x14(%rbp),%edx
shl    $0x2,%edx
imul   %edx,%ecx
mov    -0x34(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
shl    $0x2,%ecx
mov    -0x28(%rbp),%esi
shl    $0x2,%esi
add    %esi,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x14(%rbp),%edx
shl    $0x2,%edx
imul   %edx,%ecx
mov    -0x34(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
shl    $0x2,%ecx
mov    -0x28(%rbp),%esi
shl    $0x2,%esi
add    %esi,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e7 <extract_block+0xd7>
jmp    1318 <extract_block+0x208>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11be <extract_block+0xae>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<extract_block>:
push   %rbp
push   %r15
push   %r14
push   %rbx
mov    %ecx,%eax
sub    %esi,%eax
cmp    $0x4,%eax
mov    $0x4,%ebx
cmovge %ebx,%eax
sub    %edx,%r8d
cmp    $0x4,%r8d
cmovge %ebx,%r8d
lea    -0x4(,%r8,4),%r8d
ff
lea    -0x4(,%rax,4),%eax
shl    $0x2,%ecx
cltq
lea    0xec5(%rip),%rbx
movslq %r8d,%r11
mov    (%rbx,%rax,4),%r8d
add    %esi,%r8d
shl    $0x2,%r8d
mov    0x4(%rbx,%rax,4),%r10d
add    %esi,%r10d
shl    $0x2,%r10d
mov    0x8(%rbx,%rax,4),%r14d
add    %esi,%r14d
add    0xc(%rbx,%rax,4),%esi
shl    $0x2,%r14d
shl    $0x2,%esi
lea    (%rbx,%r11,4),%r11
xor    %ebx,%ebx
xchg   %ax,%ax
mov    (%r11,%rbx,1),%r15d
add    %edx,%r15d
imul   %ecx,%r15d
lea    (%r8,%r15,1),%ebp
movslq %ebp,%rbp
movzbl (%rdi,%rbp,1),%eax
mov    %al,(%r9,%rbx,4)
mov    %rbp,%rax
or     $0x1,%rax
movzbl (%rdi,%rax,1),%eax
mov    %al,0x1(%r9,%rbx,4)
mov    %rbp,%rax
or     $0x2,%rax
movzbl (%rdi,%rax,1),%eax
mov    %al,0x2(%r9,%rbx,4)
or     $0x3,%rbp
movzbl (%rdi,%rbp,1),%eax
mov    %al,0x3(%r9,%rbx,4)
lea    (%r10,%r15,1),%eax
movslq %eax,%rbp
movzbl (%rdi,%rbp,1),%eax
mov    %al,0x4(%r9,%rbx,4)
mov    %rbp,%rax
or     $0x1,%rax
movzbl (%rdi,%rax,1),%eax
mov    %al,0x5(%r9,%rbx,4)
mov    %rbp,%rax
or     $0x2,%rax
movzbl (%rdi,%rax,1),%eax
mov    %al,0x6(%r9,%rbx,4)
or     $0x3,%rbp
movzbl (%rdi,%rbp,1),%eax
mov    %al,0x7(%r9,%rbx,4)
lea    (%r14,%r15,1),%eax
movslq %eax,%rbp
movzbl (%rdi,%rbp,1),%eax
mov    %al,0x8(%r9,%rbx,4)
mov    %rbp,%rax
or     $0x1,%rax
movzbl (%rdi,%rax,1),%eax
mov    %al,0x9(%r9,%rbx,4)
mov    %rbp,%rax
or     $0x2,%rax
movzbl (%rdi,%rax,1),%eax
mov    %al,0xa(%r9,%rbx,4)
or     $0x3,%rbp
movzbl (%rdi,%rbp,1),%eax
mov    %al,0xb(%r9,%rbx,4)
add    %esi,%r15d
movslq %r15d,%rbp
movzbl (%rdi,%rbp,1),%eax
mov    %al,0xc(%r9,%rbx,4)
mov    %rbp,%rax
or     $0x1,%rax
movzbl (%rdi,%rax,1),%eax
mov    %al,0xd(%r9,%rbx,4)
mov    %rbp,%rax
or     $0x2,%rax
movzbl (%rdi,%rax,1),%eax
mov    %al,0xe(%r9,%rbx,4)
or     $0x3,%rbp
movzbl (%rdi,%rbp,1),%eax
mov    %al,0xf(%r9,%rbx,4)
add    $0x4,%rbx
cmp    $0x10,%rbx
jne    1170 <extract_block+0x70>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

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