void divname(char *file, unsigned short len, char *base, char *ext) {
  unsigned short count = 0;
  unsigned short srt = 0, dot = 0;
  for (count = 0; count < len; count++) {
    if (*(file + count) == '/') {
      srt = count;
    } else if (*(file + count) == '.') {
      dot = count;
    }
  }
  for (count = srt; count < dot; count++) {
  }
  for (count = dot; count < len; count++) {
    *(ext + (count - dot)) = *(file + count);
  }
}


x86 assembly (clang, -O0):
<divname>:
push   %rbp
mov    %rsp,%rbp
mov    %si,%ax
mov    %rdi,-0x8(%rbp)
mov    %ax,-0xa(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movw   $0x0,-0x22(%rbp)
movw   $0x0,-0x24(%rbp)
movw   $0x0,-0x26(%rbp)
movw   $0x0,-0x22(%rbp)
movzwl -0x22(%rbp),%eax
movzwl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jge    119f <divname+0x9f>
mov    -0x8(%rbp),%rax
movzwl -0x22(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jne    1164 <divname+0x64>
mov    -0x22(%rbp),%ax
mov    %ax,-0x24(%rbp)
jmp    1189 <divname+0x89>
mov    -0x8(%rbp),%rax
movzwl -0x22(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    1184 <divname+0x84>
mov    -0x22(%rbp),%ax
mov    %ax,-0x26(%rbp)
jmp    1189 <divname+0x89>
jmp    118e <divname+0x8e>
mov    -0x22(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x22(%rbp)
jmp    112f <divname+0x2f>
mov    -0x24(%rbp),%ax
mov    %ax,-0x22(%rbp)
movzwl -0x22(%rbp),%eax
movzwl -0x26(%rbp),%ecx
cmp    %ecx,%eax
jge    11cd <divname+0xcd>
jmp    11bc <divname+0xbc>
mov    -0x22(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x22(%rbp)
jmp    11a7 <divname+0xa7>
mov    -0x26(%rbp),%ax
mov    %ax,-0x22(%rbp)
movzwl -0x22(%rbp),%eax
movzwl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jge    1218 <divname+0x118>
mov    -0x8(%rbp),%rax
movzwl -0x22(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
movzwl -0x22(%rbp),%ecx
movzwl -0x26(%rbp),%esi
sub    %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x22(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x22(%rbp)
jmp    11d5 <divname+0xd5>
pop    %rbp
ret

x86 assembly (clang, -O2):
<divname>:
push   %r14
push   %rbx
movzwl %si,%r11d
test   %esi,%esi
je     1122 <divname+0x22>
lea    -0x1(%r11),%rax
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    1126 <divname+0x26>
xor    %eax,%eax
xor    %edx,%edx
jmp    1174 <divname+0x74>
xor    %ebx,%ebx
jmp    1195 <divname+0x95>
mov    %r11d,%r9d
and    $0xfffffffc,%r9d
xor    %eax,%eax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpb   $0x2e,(%rdi,%rax,1)
cmove  %eax,%edx
cmpb   $0x2e,0x1(%rdi,%rax,1)
lea    0x1(%rax),%ebx
cmovne %edx,%ebx
lea    0x2(%rax),%r10d
cmpb   $0x2e,0x2(%rdi,%rax,1)
cmovne %ebx,%r10d
lea    0x3(%rax),%edx
cmpb   $0x2e,0x3(%rdi,%rax,1)
cmovne %r10d,%edx
add    $0x4,%rax
cmp    %r9,%rax
jne    1140 <divname+0x40>
mov    %edx,%ebx
test   %r8,%r8
je     1195 <divname+0x95>
nopl   0x0(%rax,%rax,1)
cmpb   $0x2e,(%rdi,%rax,1)
mov    %eax,%ebx
cmovne %edx,%ebx
add    $0x1,%rax
mov    %ebx,%edx
add    $0xffffffffffffffff,%r8
jne    1180 <divname+0x80>
cmp    %si,%bx
jae    136b <divname+0x26b>
movzwl %bx,%r8d
mov    %r11,%r9
sub    %r8,%r9
mov    %r8,%rsi
cmp    $0x8,%r9
jb     12fe <divname+0x1fe>
lea    (%rdi,%r8,1),%r10
lea    (%rdi,%r11,1),%rax
cmp    %rcx,%rax
jbe    11d2 <divname+0xd2>
lea    (%rcx,%r9,1),%rax
mov    %r8,%rsi
cmp    %rax,%r10
jb     12fe <divname+0x1fe>
cmp    $0x20,%r9
jae    11df <divname+0xdf>
xor    %edx,%edx
jmp    12ca <divname+0x1ca>
mov    %r9,%rdx
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%rax
mov    %rax,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%r14d
and    $0x3,%r14d
cmp    $0x60,%rax
jae    1206 <divname+0x106>
xor    %ebx,%ebx
jmp    1278 <divname+0x178>
and    $0xfffffffffffffffc,%rsi
lea    (%r8,%rdi,1),%rax
add    $0x70,%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x70(%rax,%rbx,1),%xmm0
movups -0x60(%rax,%rbx,1),%xmm1
movups %xmm0,(%rcx,%rbx,1)
movups %xmm1,0x10(%rcx,%rbx,1)
movups -0x50(%rax,%rbx,1),%xmm0
movups -0x40(%rax,%rbx,1),%xmm1
movups %xmm0,0x20(%rcx,%rbx,1)
movups %xmm1,0x30(%rcx,%rbx,1)
movups -0x30(%rax,%rbx,1),%xmm0
movups -0x20(%rax,%rbx,1),%xmm1
movups %xmm0,0x40(%rcx,%rbx,1)
movups %xmm1,0x50(%rcx,%rbx,1)
movups -0x10(%rax,%rbx,1),%xmm0
movups (%rax,%rbx,1),%xmm1
movups %xmm0,0x60(%rcx,%rbx,1)
movups %xmm1,0x70(%rcx,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rsi
jne    1220 <divname+0x120>
test   %r14,%r14
je     12bb <divname+0x1bb>
lea    (%rbx,%rcx,1),%rax
add    $0x10,%rax
add    %r8,%rbx
lea    (%rdi,%rbx,1),%rsi
add    $0x10,%rsi
shl    $0x5,%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rsi,%rbx,1),%xmm0
movups (%rsi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rax,%rbx,1)
movups %xmm1,(%rax,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r14
jne    12a0 <divname+0x1a0>
cmp    %rdx,%r9
je     136b <divname+0x26b>
test   $0x18,%r9b
je     12f8 <divname+0x1f8>
mov    %r9,%rax
and    $0xfffffffffffffff8,%rax
lea    (%rax,%r8,1),%rsi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r10,%rdx,1),%rbx
mov    %rbx,(%rcx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rax
jne    12e0 <divname+0x1e0>
cmp    %rax,%r9
jne    12fe <divname+0x1fe>
jmp    136b <divname+0x26b>
add    %r8,%rdx
mov    %rdx,%rsi
mov    %r11d,%edx
sub    %esi,%edx
mov    %rsi,%r9
not    %r9
add    %r11,%r9
and    $0x3,%rdx
je     1331 <divname+0x231>
mov    %rcx,%rbx
sub    %r8,%rbx
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,1),%eax
mov    %al,(%rbx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    1320 <divname+0x220>
cmp    $0x3,%r9
jb     136b <divname+0x26b>
sub    %r8,%rcx
add    $0x3,%rcx
xchg   %ax,%ax
movzbl (%rdi,%rsi,1),%eax
mov    %al,-0x3(%rcx,%rsi,1)
movzbl 0x1(%rdi,%rsi,1),%eax
mov    %al,-0x2(%rcx,%rsi,1)
movzbl 0x2(%rdi,%rsi,1),%eax
mov    %al,-0x1(%rcx,%rsi,1)
movzbl 0x3(%rdi,%rsi,1),%eax
mov    %al,(%rcx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r11
jne    1340 <divname+0x240>
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @divname(i8* %0, i16 zeroext %1, i8* %2, i8* %3) {
%5 = alloca i8*
%6 = alloca i16
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i16
%10 = alloca i16
%11 = alloca i16
store i8* %0, i8** %5
store i16 %1, i16* %6
store i8* %2, i8** %7
store i8* %3, i8** %8
store i16 0, i16* %9
store i16 0, i16* %10
store i16 0, i16* %11
store i16 0, i16* %9
br label %12
12: ; preds = %42, %4
%13 = load i16, i16* %9
%14 = zext i16 %13 to i32
%15 = load i16, i16* %6
%16 = zext i16 %15 to i32
%17 = icmp slt i32 %14, %16
br i1 %17, label %18, label %45
18: ; preds = %12
%19 = load i8*, i8** %5
%20 = load i16, i16* %9
%21 = zext i16 %20 to i32
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %19, i64 %22
%24 = load i8, i8* %23
%25 = sext i8 %24 to i32
%26 = icmp eq i32 %25, 47
br i1 %26, label %27, label %29
27: ; preds = %18
%28 = load i16, i16* %9
store i16 %28, i16* %10
br label %41
29: ; preds = %18
%30 = load i8*, i8** %5
%31 = load i16, i16* %9
%32 = zext i16 %31 to i32
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %30, i64 %33
%35 = load i8, i8* %34
%36 = sext i8 %35 to i32
%37 = icmp eq i32 %36, 46
br i1 %37, label %38, label %40
38: ; preds = %29
%39 = load i16, i16* %9
store i16 %39, i16* %11
br label %40
40: ; preds = %38, %29
br label %41
41: ; preds = %40, %27
br label %42
42: ; preds = %41
%43 = load i16, i16* %9
%44 = add i16 %43, 1
store i16 %44, i16* %9
br label %12
45: ; preds = %12
%46 = load i16, i16* %10
store i16 %46, i16* %9
br label %47
47: ; preds = %54, %45
%48 = load i16, i16* %9
%49 = zext i16 %48 to i32
%50 = load i16, i16* %11
%51 = zext i16 %50 to i32
%52 = icmp slt i32 %49, %51
br i1 %52, label %53, label %57
53: ; preds = %47
br label %54
54: ; preds = %53
%55 = load i16, i16* %9
%56 = add i16 %55, 1
store i16 %56, i16* %9
br label %47
57: ; preds = %47
%58 = load i16, i16* %11
store i16 %58, i16* %9
br label %59
59: ; preds = %80, %57
%60 = load i16, i16* %9
%61 = zext i16 %60 to i32
%62 = load i16, i16* %6
%63 = zext i16 %62 to i32
%64 = icmp slt i32 %61, %63
br i1 %64, label %65, label %83
65: ; preds = %59
%66 = load i8*, i8** %5
%67 = load i16, i16* %9
%68 = zext i16 %67 to i32
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8, i8* %66, i64 %69
%71 = load i8, i8* %70
%72 = load i8*, i8** %8
%73 = load i16, i16* %9
%74 = zext i16 %73 to i32
%75 = load i16, i16* %11
%76 = zext i16 %75 to i32
%77 = sub nsw i32 %74, %76
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i8, i8* %72, i64 %78
store i8 %71, i8* %79
br label %80
80: ; preds = %65
%81 = load i16, i16* %9
%82 = add i16 %81, 1
store i16 %82, i16* %9
br label %59
83: ; preds = %59
ret void
}

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