void or_write_memory(unsigned long phys_addr, void *addr, int len, int iosize,
                     unsigned long value) {
  switch (iosize) {
  case 1:
    while (len) {
      *(unsigned char *)addr |= value;
      len -= iosize;
      addr += iosize;
    }
    break;
  case 2:
    while (len) {
      *(unsigned short *)addr |= value;
      len -= iosize;
      addr += iosize;
    }
    break;
  case 4:
    while (len) {
      *(unsigned long *)addr |= value;
      len -= iosize;
      addr += iosize;
    }
    break;
  }
}


x86 assembly (clang, -O0):
<or_write_memory>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
sub    $0x1,%eax
je     114c <or_write_memory+0x4c>
jmp    112a <or_write_memory+0x2a>
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
je     1191 <or_write_memory+0x91>
jmp    113b <or_write_memory+0x3b>
mov    -0x24(%rbp),%eax
sub    $0x4,%eax
je     11d7 <or_write_memory+0xd7>
jmp    121a <or_write_memory+0x11a>
jmp    1151 <or_write_memory+0x51>
cmpl   $0x0,-0x14(%rbp)
je     118c <or_write_memory+0x8c>
mov    -0x20(%rbp),%rdx
mov    -0x10(%rbp),%rax
movzbl (%rax),%ecx
or     %rdx,%rcx
mov    %cl,(%rax)
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
jmp    1151 <or_write_memory+0x51>
jmp    121a <or_write_memory+0x11a>
jmp    1196 <or_write_memory+0x96>
cmpl   $0x0,-0x14(%rbp)
je     11d2 <or_write_memory+0xd2>
mov    -0x20(%rbp),%rdx
mov    -0x10(%rbp),%rax
movzwl (%rax),%ecx
or     %rdx,%rcx
mov    %cx,(%rax)
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
jmp    1196 <or_write_memory+0x96>
jmp    121a <or_write_memory+0x11a>
jmp    11dc <or_write_memory+0xdc>
cmpl   $0x0,-0x14(%rbp)
je     1215 <or_write_memory+0x115>
mov    -0x20(%rbp),%rcx
mov    -0x10(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
jmp    11dc <or_write_memory+0xdc>
jmp    121a <or_write_memory+0x11a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<or_write_memory>:
push   %r14
push   %rbx
cmp    $0x1,%ecx
je     1190 <or_write_memory+0x90>
cmp    $0x2,%ecx
je     11ae <or_write_memory+0xae>
cmp    $0x4,%ecx
jne    13dc <or_write_memory+0x2dc>
test   %edx,%edx
je     13dc <or_write_memory+0x2dc>
lea    -0x4(%rdx),%eax
mov    %eax,%ecx
shr    $0x2,%ecx
lea    0x1(%rcx),%edi
test   $0x3,%dil
je     1161 <or_write_memory+0x61>
add    $0x1,%cl
movzbl %cl,%ecx
and    $0x3,%ecx
shl    $0x2,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
or     %r8,(%rsi,%rdi,1)
add    $0x4,%rdi
cmp    %edi,%ecx
jne    1150 <or_write_memory+0x50>
add    %rdi,%rsi
sub    %edi,%edx
cmp    $0xc,%eax
jb     13dc <or_write_memory+0x2dc>
mov    %edx,%eax
xor    %ecx,%ecx
xchg   %ax,%ax
or     %r8,(%rsi,%rcx,1)
or     %r8,0x4(%rsi,%rcx,1)
or     %r8,0x8(%rsi,%rcx,1)
or     %r8,0xc(%rsi,%rcx,1)
add    $0x10,%rcx
cmp    %ecx,%eax
jne    1170 <or_write_memory+0x70>
jmp    13dc <or_write_memory+0x2dc>
test   %edx,%edx
je     13dc <or_write_memory+0x2dc>
lea    -0x1(%rdx),%r11d
cmp    $0x7,%r11d
jae    12a2 <or_write_memory+0x1a2>
mov    %rsi,%rax
jmp    13cc <or_write_memory+0x2cc>
test   %edx,%edx
je     13dc <or_write_memory+0x2dc>
lea    -0x2(%rdx),%eax
cmp    $0x1e,%eax
jb     127e <or_write_memory+0x17e>
shr    %eax
add    $0x1,%eax
mov    %eax,%r9d
and    $0xfffffff0,%r9d
movd   %r8d,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x10(%r9),%rcx
mov    %rcx,%rbx
shr    $0x4,%rbx
add    $0x1,%rbx
test   %rcx,%rcx
je     134a <or_write_memory+0x24a>
mov    %rbx,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %edi,%edi
xchg   %ax,%ax
movdqu (%rsi,%rdi,1),%xmm1
movdqu 0x10(%rsi,%rdi,1),%xmm2
movdqu 0x20(%rsi,%rdi,1),%xmm3
movdqu 0x30(%rsi,%rdi,1),%xmm4
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,(%rsi,%rdi,1)
movdqu %xmm2,0x10(%rsi,%rdi,1)
por    %xmm0,%xmm3
por    %xmm0,%xmm4
movdqu %xmm3,0x20(%rsi,%rdi,1)
movdqu %xmm4,0x30(%rsi,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1200 <or_write_memory+0x100>
test   $0x1,%bl
je     126b <or_write_memory+0x16b>
movdqu (%rsi,%rdi,1),%xmm1
movdqu 0x10(%rsi,%rdi,1),%xmm2
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,(%rsi,%rdi,1)
movdqu %xmm2,0x10(%rsi,%rdi,1)
cmp    %rax,%r9
je     13dc <or_write_memory+0x2dc>
lea    (%rsi,%r9,2),%rsi
sub    %r9d,%edx
sub    %r9d,%edx
mov    %edx,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
or     %r8w,(%rsi,%rcx,1)
add    $0x2,%rcx
cmp    %ecx,%eax
jne    1290 <or_write_memory+0x190>
jmp    13dc <or_write_memory+0x2dc>
movabs $0x1ffffffe0,%rcx
movzbl %r8b,%r9d
cmp    $0x1f,%r11d
jae    12bd <or_write_memory+0x1bd>
xor    %edi,%edi
jmp    138b <or_write_memory+0x28b>
lea    0x1(%r11),%r10
mov    %r10,%rdi
and    %rcx,%rdi
movd   %r9d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rdi),%rax
mov    %rax,%r14
shr    $0x5,%r14
add    $0x1,%r14
test   %rax,%rax
je     135a <or_write_memory+0x25a>
mov    %r14,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movdqu (%rsi,%rax,1),%xmm1
movdqu 0x10(%rsi,%rax,1),%xmm2
movdqu 0x20(%rsi,%rax,1),%xmm3
movdqu 0x30(%rsi,%rax,1),%xmm4
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,(%rsi,%rax,1)
movdqu %xmm2,0x10(%rsi,%rax,1)
por    %xmm0,%xmm3
por    %xmm0,%xmm4
movdqu %xmm3,0x20(%rsi,%rax,1)
movdqu %xmm4,0x30(%rsi,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rbx
jne    1300 <or_write_memory+0x200>
jmp    135c <or_write_memory+0x25c>
xor    %edi,%edi
test   $0x1,%bl
jne    124d <or_write_memory+0x14d>
jmp    126b <or_write_memory+0x16b>
xor    %eax,%eax
test   $0x1,%r14b
je     1380 <or_write_memory+0x280>
movdqu (%rsi,%rax,1),%xmm1
movdqu 0x10(%rsi,%rax,1),%xmm2
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,(%rsi,%rax,1)
movdqu %xmm2,0x10(%rsi,%rax,1)
cmp    %rdi,%r10
je     13dc <or_write_memory+0x2dc>
test   $0x18,%r10b
je     13e0 <or_write_memory+0x2e0>
add    $0x1,%r11
add    $0x18,%rcx
and    %r11,%rcx
lea    (%rsi,%rcx,1),%rax
sub    %ecx,%edx
movd   %r9d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movq   (%rsi,%rdi,1),%xmm1
por    %xmm0,%xmm1
movq   %xmm1,(%rsi,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%rcx
jne    13b0 <or_write_memory+0x2b0>
cmp    %rcx,%r11
je     13dc <or_write_memory+0x2dc>
mov    %edx,%ecx
xor    %edx,%edx
or     %r8b,(%rax,%rdx,1)
add    $0x1,%rdx
cmp    %edx,%ecx
jne    13d0 <or_write_memory+0x2d0>
pop    %rbx
pop    %r14
ret
sub    %edi,%edx
add    %rdi,%rsi
jmp    11a6 <or_write_memory+0xa6>

LLVM IR (-O0):
define void @or_write_memory(i64 %0, i8* %1, i32 %2, i32 %3, i64 %4) {
%6 = alloca i64
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i64
store i64 %0, i64* %6
store i8* %1, i8** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i64 %4, i64* %10
%11 = load i32, i32* %9
switch i32 %11, label %69 [
i32 1, label %12
i32 2, label %31
i32 4, label %51
]
12: ; preds = %5
br label %13
13: ; preds = %16, %12
%14 = load i32, i32* %8
%15 = icmp ne i32 %14, 0
br i1 %15, label %16, label %30
16: ; preds = %13
%17 = load i64, i64* %10
%18 = load i8*, i8** %7
%19 = load i8, i8* %18
%20 = zext i8 %19 to i64
%21 = or i64 %20, %17
%22 = trunc i64 %21 to i8
store i8 %22, i8* %18
%23 = load i32, i32* %9
%24 = load i32, i32* %8
%25 = sub nsw i32 %24, %23
store i32 %25, i32* %8
%26 = load i32, i32* %9
%27 = load i8*, i8** %7
%28 = sext i32 %26 to i64
%29 = getelementptr i8, i8* %27, i64 %28
store i8* %29, i8** %7
br label %13
30: ; preds = %13
br label %69
31: ; preds = %5
br label %32
32: ; preds = %35, %31
%33 = load i32, i32* %8
%34 = icmp ne i32 %33, 0
br i1 %34, label %35, label %50
35: ; preds = %32
%36 = load i64, i64* %10
%37 = load i8*, i8** %7
%38 = bitcast i8* %37 to i16*
%39 = load i16, i16* %38
%40 = zext i16 %39 to i64
%41 = or i64 %40, %36
%42 = trunc i64 %41 to i16
store i16 %42, i16* %38
%43 = load i32, i32* %9
%44 = load i32, i32* %8
%45 = sub nsw i32 %44, %43
store i32 %45, i32* %8
%46 = load i32, i32* %9
%47 = load i8*, i8** %7
%48 = sext i32 %46 to i64
%49 = getelementptr i8, i8* %47, i64 %48
store i8* %49, i8** %7
br label %32
50: ; preds = %32
br label %69
51: ; preds = %5
br label %52
52: ; preds = %55, %51
%53 = load i32, i32* %8
%54 = icmp ne i32 %53, 0
br i1 %54, label %55, label %68
55: ; preds = %52
%56 = load i64, i64* %10
%57 = load i8*, i8** %7
%58 = bitcast i8* %57 to i64*
%59 = load i64, i64* %58
%60 = or i64 %59, %56
store i64 %60, i64* %58
%61 = load i32, i32* %9
%62 = load i32, i32* %8
%63 = sub nsw i32 %62, %61
store i32 %63, i32* %8
%64 = load i32, i32* %9
%65 = load i8*, i8** %7
%66 = sext i32 %64 to i64
%67 = getelementptr i8, i8* %65, i64 %66
store i8* %67, i8** %7
br label %52
68: ; preds = %52
br label %69
69: ; preds = %5, %68, %50, %30
ret void
}

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