#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ md5_digest(void const *, size_t const, unsigned char *);
int /*<<< orphan*/ sprintf(char *, char *, unsigned int);
int /*<<< orphan*/ strcat(char *, char *);
char *md5_digest_str(const void *v, const size_t n, const int base64) {
  unsigned char md5[16], *p;
  static char res[33] = {0};
  char *q;
  md5_digest(v, n, md5);
  if (base64) {
    const char b64[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    for (p = md5, q = res; p < md5 + 16; p += 3, q += 4) {
      char s[5] = "====";
      s[0] = b64[(p + 0 > md5 + 16 ? *(p + 0) : 0) >> 2];
      s[1] = b64[((p + 0 > md5 + 16 ? *(p + 0) : 0) & 0x3 << 4) |
                 ((p + 1 > md5 + 16 ? *(p + 1) : 0) & 0xf0 >> 4)];
      if (p + 1 < md5 + 16)
        s[2] = b64[((p + 1 > md5 + 16 ? *(p + 1) : 0) & 0xf << 2) |
                   ((p + 2 > md5 + 16 ? *(p + 2) : 0) & 0xc0 >> 4)];
      if (p + 2 < md5 + 16)
        s[3] = b64[(p + 2 > md5 + 16 ? *(p + 2) : 0) & 0x3f];
      strcat(res, s);
    }
  } else {
    for (p = md5, q = res; p < md5 + 16; ++p, q += 2)
      sprintf(q, "%02x", (unsigned int)*p);
  }
  return res;
}


x86 assembly (clang, -O0):
<md5_digest_str>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    -0x30(%rbp),%rdx
call   1060 <md5_digest@plt>
cmpl   $0x0,-0x14(%rbp)
je     140a <md5_digest_str+0x2ca>
lea    -0x90(%rbp),%rdi
lea    0xe81(%rip),%rsi
mov    $0x41,%edx
call   1030 <memcpy@plt>
lea    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
lea    0x2eb8(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
lea    -0x30(%rbp),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jae    1405 <md5_digest_str+0x2c5>
mov    0xe8a(%rip),%eax
mov    %eax,-0x95(%rbp)
mov    0xe82(%rip),%al
mov    %al,-0x91(%rbp)
mov    -0x38(%rbp),%rax
lea    -0x30(%rbp),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jbe    11f0 <md5_digest_str+0xb0>
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x9c(%rbp)
jmp    11fd <md5_digest_str+0xbd>
xor    %eax,%eax
mov    %eax,-0x9c(%rbp)
jmp    11fd <md5_digest_str+0xbd>
mov    -0x9c(%rbp),%eax
sar    $0x2,%eax
cltq
mov    -0x90(%rbp,%rax,1),%al
mov    %al,-0x95(%rbp)
mov    -0x38(%rbp),%rax
lea    -0x30(%rbp),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jbe    123c <md5_digest_str+0xfc>
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0xa0(%rbp)
jmp    1249 <md5_digest_str+0x109>
xor    %eax,%eax
mov    %eax,-0xa0(%rbp)
jmp    1249 <md5_digest_str+0x109>
mov    -0xa0(%rbp),%eax
and    $0x30,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
lea    -0x30(%rbp),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jbe    1284 <md5_digest_str+0x144>
mov    -0x38(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0xa8(%rbp)
jmp    1291 <md5_digest_str+0x151>
xor    %eax,%eax
mov    %eax,-0xa8(%rbp)
jmp    1291 <md5_digest_str+0x151>
mov    -0xa4(%rbp),%eax
mov    -0xa8(%rbp),%ecx
and    $0xf,%ecx
or     %ecx,%eax
cltq
mov    -0x90(%rbp,%rax,1),%al
mov    %al,-0x94(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
lea    -0x30(%rbp),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jae    136b <md5_digest_str+0x22b>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
lea    -0x30(%rbp),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jbe    12f6 <md5_digest_str+0x1b6>
mov    -0x38(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0xac(%rbp)
jmp    1303 <md5_digest_str+0x1c3>
xor    %eax,%eax
mov    %eax,-0xac(%rbp)
jmp    1303 <md5_digest_str+0x1c3>
mov    -0xac(%rbp),%eax
and    $0x3c,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x38(%rbp),%rax
add    $0x2,%rax
lea    -0x30(%rbp),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jbe    133e <md5_digest_str+0x1fe>
mov    -0x38(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    %eax,-0xb4(%rbp)
jmp    134b <md5_digest_str+0x20b>
xor    %eax,%eax
mov    %eax,-0xb4(%rbp)
jmp    134b <md5_digest_str+0x20b>
mov    -0xb0(%rbp),%eax
mov    -0xb4(%rbp),%ecx
and    $0xc,%ecx
or     %ecx,%eax
cltq
mov    -0x90(%rbp,%rax,1),%al
mov    %al,-0x93(%rbp)
mov    -0x38(%rbp),%rax
add    $0x2,%rax
lea    -0x30(%rbp),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jae    13d5 <md5_digest_str+0x295>
mov    -0x38(%rbp),%rax
add    $0x2,%rax
lea    -0x30(%rbp),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jbe    13b0 <md5_digest_str+0x270>
mov    -0x38(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    %eax,-0xb8(%rbp)
jmp    13bd <md5_digest_str+0x27d>
xor    %eax,%eax
mov    %eax,-0xb8(%rbp)
jmp    13bd <md5_digest_str+0x27d>
mov    -0xb8(%rbp),%eax
and    $0x3f,%eax
cltq
mov    -0x90(%rbp,%rax,1),%al
mov    %al,-0x92(%rbp)
lea    -0x95(%rbp),%rsi
lea    0x2c6d(%rip),%rdi
call   1040 <strcat@plt>
mov    -0x38(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x40(%rbp)
jmp    119c <md5_digest_str+0x5c>
jmp    146b <md5_digest_str+0x32b>
lea    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
lea    0x2c37(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
lea    -0x30(%rbp),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jae    1466 <md5_digest_str+0x326>
mov    -0x40(%rbp),%rdi
mov    -0x38(%rbp),%rax
movzbl (%rax),%edx
lea    0xc02(%rip),%rsi
call   1050 <sprintf@plt>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
jmp    141d <md5_digest_str+0x2dd>
jmp    146b <md5_digest_str+0x32b>
lea    0x2bde(%rip),%rax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<md5_digest_str>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %edx,%ebx
lea    0x10(%rsp),%r14
mov    %r14,%rdx
call   1050 <md5_digest@plt>
test   %ebx,%ebx
je     11f7 <md5_digest_str+0xc7>
movb   $0x0,0xc(%rsp)
movl   $0x41414141,0x8(%rsp)
41
lea    0x2eea(%rip),%rbx
lea    0x8(%rsp),%r14
mov    %rbx,%rdi
mov    %r14,%rsi
call   1030 <strcat@plt>
movb   $0x0,0xc(%rsp)
movl   $0x41414141,0x8(%rsp)
41
mov    %rbx,%rdi
mov    %r14,%rsi
call   1030 <strcat@plt>
movb   $0x0,0xc(%rsp)
movl   $0x41414141,0x8(%rsp)
41
mov    %rbx,%rdi
mov    %r14,%rsi
call   1030 <strcat@plt>
movb   $0x0,0xc(%rsp)
movl   $0x41414141,0x8(%rsp)
41
mov    %rbx,%rdi
mov    %r14,%rsi
call   1030 <strcat@plt>
movb   $0x0,0xc(%rsp)
movl   $0x41414141,0x8(%rsp)
41
mov    %rbx,%rdi
mov    %r14,%rsi
call   1030 <strcat@plt>
movl   $0x3d3d3d3d,0x8(%rsp)
3d
movb   $0x0,0xc(%rsp)
movw   $0x4141,0x8(%rsp)
mov    %rbx,%rdi
mov    %r14,%rsi
call   1030 <strcat@plt>
jmp    122c <md5_digest_str+0xfc>
lea    0x20(%rsp),%r12
lea    0x2e4d(%rip),%rbx
lea    0xdfb(%rip),%r15
nopw   0x0(%rax,%rax,1)
movzbl (%r14),%edx
mov    %rbx,%rdi
mov    %r15,%rsi
call   1040 <sprintf@plt>
add    $0x1,%r14
add    $0x2,%rbx
cmp    %r12,%r14
jb     1210 <md5_digest_str+0xe0>
lea    0x2e1d(%rip),%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
@md5_digest_str.res = internal global [33 x i8] zeroinitializer
@__const.md5_digest_str.s = [5 x i8] c"====\00"
@.str = [5 x i8] c"%02x\00"
define i8* @md5_digest_str(i8* %0, i64 %1, i32 %2) {
%4 = alloca [16 x i8]
%5 = alloca [5 x i8]
%6 = getelementptr inbounds [16 x i8], [16 x i8]* %4, i64 0, i64 0
%7 = call i32 @md5_digest(i8* %0, i64 %1, i8* %6)
%8 = icmp eq i32 %2, 0
%9 = getelementptr inbounds [16 x i8], [16 x i8]* %4, i64 0, i64 16
br i1 %8, label %21, label %10
10: ; preds = %3
%11 = getelementptr inbounds [5 x i8], [5 x i8]* %5, i64 0, i64 0
%12 = getelementptr inbounds [5 x i8], [5 x i8]* %5, i64 0, i64 1
%13 = getelementptr inbounds [5 x i8], [5 x i8]* %5, i64 0, i64 2
%14 = getelementptr inbounds [5 x i8], [5 x i8]* %5, i64 0, i64 3
store i8 65, i8* %11
store i8 65, i8* %12
store i8 65, i8* %13
store i8 65, i8* %14
%15 = call i32 @strcat(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @md5_digest_str.res, i64 0, i64 0), i8* %11)
store i8 65, i8* %11
store i8 65, i8* %12
store i8 65, i8* %13
store i8 65, i8* %14
%16 = call i32 @strcat(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @md5_digest_str.res, i64 0, i64 0), i8* %11)
store i8 65, i8* %11
store i8 65, i8* %12
store i8 65, i8* %13
store i8 65, i8* %14
%17 = call i32 @strcat(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @md5_digest_str.res, i64 0, i64 0), i8* %11)
store i8 65, i8* %11
store i8 65, i8* %12
store i8 65, i8* %13
store i8 65, i8* %14
%18 = call i32 @strcat(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @md5_digest_str.res, i64 0, i64 0), i8* %11)
store i8 65, i8* %11
store i8 65, i8* %12
store i8 65, i8* %13
store i8 65, i8* %14
%19 = call i32 @strcat(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @md5_digest_str.res, i64 0, i64 0), i8* %11)
store i8 65, i8* %11
store i8 65, i8* %12
%20 = call i32 @strcat(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @md5_digest_str.res, i64 0, i64 0), i8* %11)
br label %30
21: ; preds = %3, %21
%22 = phi i8* [ %28, %21 ], [ getelementptr inbounds ([33 x i8], [33 x i8]* @md5_digest_str.res, i64 0, i64 0), %3 ]
%23 = phi i8* [ %27, %21 ], [ %6, %3 ]
%24 = load i8, i8* %23
%25 = zext i8 %24 to i32
%26 = call i32 @sprintf(i8* dereferenceable(1) %22, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %25)
%27 = getelementptr inbounds i8, i8* %23, i64 1
%28 = getelementptr inbounds i8, i8* %22, i64 2
%29 = icmp ult i8* %27, %9
br i1 %29, label %21, label %30
30: ; preds = %21, %10
ret i8* getelementptr inbounds ([33 x i8], [33 x i8]* @md5_digest_str.res, i64 0, i64 0)
}