void mangle(unsigned char *data) {
  unsigned char a, x, temp, i, offset, carry = 0;
  a = data[0xf];
  do {
    x = a;
    offset = 1;
    carry = 1;
    a += data[offset] + carry;
    data[offset] = a & 0xf;
    a = data[offset++];
    a += data[offset] + carry;
    a = (~a) & 0xf;
    temp = a;
    a = data[offset];
    data[offset++] = temp & 0xf;
    a += data[offset] + carry;
    if (a < 0x10) {
      temp = a;
      a = data[offset];
      data[offset++] = temp & 0xf;
    }
    a += data[offset];
    data[offset] = a & 0xf;
    a = data[offset++];
    carry = 0;
    a += data[offset] + carry;
    temp = a;
    a = data[offset];
    data[offset++] = temp & 0xf;
    a += 8;
    if (a < 0x10) {
      a += data[offset] + carry;
    }
    temp = a;
    a = data[offset];
    data[offset++] = temp & 0xf;
    while (offset < 0x10) {
      a++;
      a += data[offset] + carry;
      data[offset] = a & 0xf;
      a = data[offset++];
    }
    offset &= 0xf;
    a = x;
    a += 0xf;
    if (a > 0x0f) {
      a &= 0xf;
      carry = 1;
    } else
      carry = 0;
    ;
  } while (carry);
}


x86 assembly (clang, -O0):
<mangle>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movb   $0x0,-0xe(%rbp)
mov    -0x8(%rbp),%rax
mov    0xf(%rax),%al
mov    %al,-0x9(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0xa(%rbp)
movb   $0x1,-0xd(%rbp)
movb   $0x1,-0xe(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movzbl -0xe(%rbp),%eax
add    %eax,%ecx
movzbl -0x9(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x9(%rbp)
movzbl -0x9(%rbp),%eax
and    $0xf,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0xd(%rbp),%cl
mov    %cl,%dl
add    $0x1,%dl
mov    %dl,-0xd(%rbp)
movzbl %cl,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x9(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movzbl -0xe(%rbp),%eax
add    %eax,%ecx
movzbl -0x9(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x9(%rbp)
movzbl -0x9(%rbp),%eax
xor    $0xffffffff,%eax
and    $0xf,%eax
mov    %al,-0x9(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0xb(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x9(%rbp)
movzbl -0xb(%rbp),%eax
and    $0xf,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0xd(%rbp),%cl
mov    %cl,%sil
add    $0x1,%sil
mov    %sil,-0xd(%rbp)
movzbl %cl,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movzbl -0xe(%rbp),%eax
add    %eax,%ecx
movzbl -0x9(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x9(%rbp)
movzbl -0x9(%rbp),%eax
cmp    $0x10,%eax
jge    1225 <mangle+0x125>
mov    -0x9(%rbp),%al
mov    %al,-0xb(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x9(%rbp)
movzbl -0xb(%rbp),%eax
and    $0xf,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0xd(%rbp),%cl
mov    %cl,%sil
add    $0x1,%sil
mov    %sil,-0xd(%rbp)
movzbl %cl,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movzbl -0x9(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x9(%rbp)
movzbl -0x9(%rbp),%eax
and    $0xf,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0xd(%rbp),%cl
mov    %cl,%dl
add    $0x1,%dl
mov    %dl,-0xd(%rbp)
movzbl %cl,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x9(%rbp)
movb   $0x0,-0xe(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movzbl -0xe(%rbp),%eax
add    %eax,%ecx
movzbl -0x9(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x9(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0xb(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x9(%rbp)
movzbl -0xb(%rbp),%eax
and    $0xf,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0xd(%rbp),%cl
mov    %cl,%sil
add    $0x1,%sil
mov    %sil,-0xd(%rbp)
movzbl %cl,%ecx
mov    %dl,(%rax,%rcx,1)
movzbl -0x9(%rbp),%eax
add    $0x8,%eax
mov    %al,-0x9(%rbp)
movzbl -0x9(%rbp),%eax
cmp    $0x10,%eax
jge    12ec <mangle+0x1ec>
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movzbl -0xe(%rbp),%eax
add    %eax,%ecx
movzbl -0x9(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x9(%rbp)
mov    -0x9(%rbp),%al
mov    %al,-0xb(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x9(%rbp)
movzbl -0xb(%rbp),%eax
and    $0xf,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0xd(%rbp),%cl
mov    %cl,%sil
add    $0x1,%sil
mov    %sil,-0xd(%rbp)
movzbl %cl,%ecx
mov    %dl,(%rax,%rcx,1)
movzbl -0xd(%rbp),%eax
cmp    $0x10,%eax
jge    1382 <mangle+0x282>
mov    -0x9(%rbp),%al
add    $0x1,%al
mov    %al,-0x9(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movzbl -0xe(%rbp),%eax
add    %eax,%ecx
movzbl -0x9(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x9(%rbp)
movzbl -0x9(%rbp),%eax
and    $0xf,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movzbl -0xd(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0xd(%rbp),%cl
mov    %cl,%dl
add    $0x1,%dl
mov    %dl,-0xd(%rbp)
movzbl %cl,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x9(%rbp)
jmp    1321 <mangle+0x221>
movzbl -0xd(%rbp),%eax
and    $0xf,%eax
mov    %al,-0xd(%rbp)
mov    -0xa(%rbp),%al
mov    %al,-0x9(%rbp)
movzbl -0x9(%rbp),%eax
add    $0xf,%eax
mov    %al,-0x9(%rbp)
movzbl -0x9(%rbp),%eax
cmp    $0xf,%eax
jle    13bc <mangle+0x2bc>
movzbl -0x9(%rbp),%eax
and    $0xf,%eax
mov    %al,-0x9(%rbp)
movb   $0x1,-0xe(%rbp)
jmp    13c0 <mangle+0x2c0>
movb   $0x0,-0xe(%rbp)
jmp    13c5 <mangle+0x2c5>
cmpb   $0x0,-0xe(%rbp)
jne    1116 <mangle+0x16>
pop    %rbp
ret

x86 assembly (clang, -O2):
<mangle>:
mov    0xf(%rdi),%r10b
mov    $0x10,%r8d
nopw   0x0(%rax,%rax,1)
mov    0x1(%rdi),%dl
add    %r10b,%dl
add    $0x1,%dl
mov    %edx,%eax
and    $0xf,%al
mov    %al,0x1(%rdi)
mov    0x2(%rdi),%al
mov    0x3(%rdi),%sil
add    $0x1,%al
add    %al,%dl
not    %dl
and    $0xf,%dl
mov    %dl,0x2(%rdi)
add    %sil,%al
mov    $0x3,%r9b
cmp    $0xf,%al
ja     1150 <mangle+0x50>
mov    %al,0x3(%rdi)
mov    0x4(%rdi),%dl
mov    $0x4,%r9b
jmp    1154 <mangle+0x54>
nopl   0x0(%rax,%rax,1)
mov    %esi,%edx
mov    %eax,%esi
add    %sil,%dl
movzbl %r9b,%esi
mov    %edx,%eax
and    $0xf,%al
mov    %al,(%rdi,%rsi,1)
mov    0x1(%rdi,%rsi,1),%al
add    %al,%dl
and    $0xf,%dl
mov    %dl,0x1(%rdi,%rsi,1)
add    $0x8,%al
cmp    $0x10,%al
movzbl 0x2(%rdi,%rsi,1),%ecx
mov    %ecx,%edx
cmovae %r8d,%edx
add    %al,%dl
and    $0xf,%dl
mov    %dl,0x2(%rdi,%rsi,1)
mov    $0x1,%eax
sub    %esi,%eax
test   $0x1,%al
jne    11a0 <mangle+0xa0>
add    $0x3,%rsi
jmp    11c0 <mangle+0xc0>
nopl   0x0(%rax,%rax,1)
mov    0x3(%rdi,%rsi,1),%al
add    %cl,%al
add    $0x1,%al
and    $0xf,%al
mov    %al,0x3(%rdi,%rsi,1)
add    $0x4,%rsi
mov    %eax,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    (%rdi,%rsi,1),%cl
add    $0x1,%cl
mov    %ecx,%eax
and    $0xf,%al
mov    %al,(%rdi,%rsi,1)
add    0x1(%rdi,%rsi,1),%cl
add    $0x1,%cl
and    $0xf,%cl
mov    %cl,0x1(%rdi,%rsi,1)
add    $0x2,%rsi
cmp    $0x10,%rsi
jne    11c0 <mangle+0xc0>
add    $0xf,%r10b
mov    %r10d,%eax
and    $0xf,%al
cmp    $0xf,%r10b
mov    %eax,%r10d
ja     1110 <mangle+0x10>
ret

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

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