#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 */
typedef int /*<<< orphan*/ szMD5Str;

/* Variables and functions */
int /*<<< orphan*/ Com_MD5HashString(unsigned char *, int, char *, size_t);
int /*<<< orphan*/ Z_Free(unsigned char *);
unsigned char *Z_Malloc(int);
int /*<<< orphan*/ memcpy(unsigned char *, ...);
size_t strlen(char *);
char *Com_HMACMD5String(const void *key, size_t keylen, const void *msg,
                        int msglen, char *out, size_t outsize) {
  unsigned char *pOPad;
  unsigned char *pIPad;
  const unsigned char *pKey = key;
  unsigned char *pTemp;
  int i, len;
  char szMD5Str[40];
  pOPad = Z_Malloc(keylen);
  pIPad = Z_Malloc(keylen);
  len = (int)(((keylen + msglen) < (keylen + 32)) ? (keylen + 32)
                                                  : (keylen + msglen));
  pTemp = Z_Malloc(len);
  for (i = 0; i < keylen; ++i) {
    pOPad[i] = pKey[i] ^ 0x5C;
    pIPad[i] = pKey[i] ^ 0x36;
  }
  memcpy(pTemp, pIPad, keylen);
  memcpy(pTemp + keylen, msg, msglen);
  Com_MD5HashString(pTemp, (int)(keylen + msglen), szMD5Str, sizeof(szMD5Str));
  memcpy(pTemp, pOPad, keylen);
  memcpy(pTemp + keylen, szMD5Str, strlen(szMD5Str));
  Com_MD5HashString(pTemp, (int)(keylen + strlen(szMD5Str)), out, outsize);
  Z_Free(pTemp);
  Z_Free(pOPad);
  Z_Free(pIPad);
  return out;
}


x86 assembly (clang, -O0):
<Com_HMACMD5String>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    %eax,%edi
call   1060 <Z_Malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    %eax,%edi
call   1060 <Z_Malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
add    $0x20,%rcx
cmp    %rcx,%rax
jae    11c8 <Com_HMACMD5String+0x78>
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x88(%rbp)
jmp    11da <Com_HMACMD5String+0x8a>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%edi
call   1060 <Z_Malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movslq -0x54(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    124b <Com_HMACMD5String+0xfb>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
xor    $0x5c,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
xor    $0x36,%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11f7 <Com_HMACMD5String+0xa7>
mov    -0x50(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdx
xor    %eax,%eax
call   1050 <memcpy@plt>
mov    -0x50(%rbp),%rdi
add    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
xor    %eax,%eax
call   1050 <memcpy@plt>
mov    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
mov    %eax,%esi
lea    -0x80(%rbp),%rdx
mov    $0x28,%ecx
call   1070 <Com_MD5HashString@plt>
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x10(%rbp),%rdx
xor    %eax,%eax
call   1050 <memcpy@plt>
mov    -0x50(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
lea    -0x80(%rbp),%rax
mov    %rax,-0xa0(%rbp)
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0xa8(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    %rax,%rdx
xor    %eax,%eax
call   1050 <memcpy@plt>
mov    -0x50(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x90(%rbp)
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0x98(%rbp),%rdi
mov    %rax,%rcx
mov    -0x90(%rbp),%rax
add    %rcx,%rax
mov    %eax,%esi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1070 <Com_MD5HashString@plt>
mov    -0x50(%rbp),%rdi
call   1030 <Z_Free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <Z_Free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <Z_Free@plt>
mov    -0x28(%rbp),%rax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Com_HMACMD5String>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,0x20(%rsp)
mov    %r8,0x28(%rsp)
mov    %ecx,%ebp
mov    %rdx,0x18(%rsp)
mov    %rsi,%r13
mov    %rdi,%r14
mov    %r13d,%edi
call   1060 <Z_Malloc@plt>
mov    %rax,%r12
mov    %r13d,%edi
call   1060 <Z_Malloc@plt>
mov    %rax,%rbx
mov    %ebp,0xc(%rsp)
movslq %ebp,%rax
add    %r13,%rax
lea    0x20(%r13),%rdi
cmp    %rdi,%rax
mov    %rax,0x10(%rsp)
cmovae %eax,%edi
call   1060 <Z_Malloc@plt>
mov    %rax,%r15
test   %r13,%r13
je     122b <Com_HMACMD5String+0xdb>
cmp    $0x8,%r13
jae    12e3 <Com_HMACMD5String+0x193>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r13b
je     11e2 <Com_HMACMD5String+0x92>
mov    (%r14,%rax,1),%dl
xor    $0x5c,%dl
mov    %dl,(%r12,%rax,1)
mov    (%r14,%rax,1),%dl
xor    $0x36,%dl
mov    %dl,(%rbx,%rax,1)
or     $0x1,%rax
add    %r13,%rcx
je     122b <Com_HMACMD5String+0xdb>
nopw   0x0(%rax,%rax,1)
movzbl (%r14,%rax,1),%ecx
xor    $0x5c,%cl
mov    %cl,(%r12,%rax,1)
movzbl (%r14,%rax,1),%ecx
xor    $0x36,%cl
mov    %cl,(%rbx,%rax,1)
movzbl 0x1(%r14,%rax,1),%ecx
xor    $0x5c,%cl
mov    %cl,0x1(%r12,%rax,1)
movzbl 0x1(%r14,%rax,1),%ecx
xor    $0x36,%cl
mov    %cl,0x1(%rbx,%rax,1)
add    $0x2,%rax
cmp    %rax,%r13
jne    11f0 <Com_HMACMD5String+0xa0>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   1050 <memcpy@plt>
mov    %r15,%rbp
add    %r13,%rbp
mov    %rbp,%rdi
mov    0x18(%rsp),%rsi
mov    0xc(%rsp),%edx
xor    %eax,%eax
call   1050 <memcpy@plt>
lea    0x30(%rsp),%r14
mov    $0x28,%ecx
mov    %r15,%rdi
mov    0x10(%rsp),%rsi
mov    %r14,%rdx
call   1070 <Com_MD5HashString@plt>
mov    %r15,%rdi
mov    %r12,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   1050 <memcpy@plt>
mov    %r14,%rdi
call   1040 <strlen@plt>
mov    %rbp,%rdi
mov    %r14,%rsi
mov    %rax,%rdx
xor    %eax,%eax
call   1050 <memcpy@plt>
mov    %r14,%rdi
call   1040 <strlen@plt>
add    %eax,%r13d
mov    %r15,%rdi
mov    %r13d,%esi
mov    0x28(%rsp),%rbp
mov    %rbp,%rdx
mov    0x20(%rsp),%rcx
call   1070 <Com_MD5HashString@plt>
mov    %r15,%rdi
call   1030 <Z_Free@plt>
mov    %r12,%rdi
call   1030 <Z_Free@plt>
mov    %rbx,%rdi
call   1030 <Z_Free@plt>
mov    %rbp,%rax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%r12,%r13,1),%rax
lea    (%rbx,%r13,1),%rdi
lea    (%r14,%r13,1),%rdx
cmp    %rdi,%r12
setb   %r8b
cmp    %rax,%rbx
setb   %r9b
cmp    %rdx,%r12
setb   %cl
cmp    %r14,%rax
seta   %sil
cmp    %rdx,%rbx
setb   %dl
cmp    %r14,%rdi
seta   %dil
xor    %eax,%eax
test   %r9b,%r8b
jne    11bd <Com_HMACMD5String+0x6d>
and    %sil,%cl
jne    11bd <Com_HMACMD5String+0x6d>
and    %dil,%dl
jne    11bd <Com_HMACMD5String+0x6d>
cmp    $0x20,%r13
jae    1341 <Com_HMACMD5String+0x1f1>
xor    %eax,%eax
jmp    1456 <Com_HMACMD5String+0x306>
mov    %r13,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rcx
mov    %rcx,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     14ad <Com_HMACMD5String+0x35d>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movaps 0xc90(%rip),%xmm0
movaps 0xc99(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movups (%r14,%rcx,1),%xmm2
movups 0x10(%r14,%rcx,1),%xmm3
xorps  %xmm0,%xmm2
xorps  %xmm0,%xmm3
movups %xmm2,(%r12,%rcx,1)
movups %xmm3,0x10(%r12,%rcx,1)
movups (%r14,%rcx,1),%xmm2
movups 0x10(%r14,%rcx,1),%xmm3
xorps  %xmm1,%xmm2
xorps  %xmm1,%xmm3
movups %xmm2,(%rbx,%rcx,1)
movups %xmm3,0x10(%rbx,%rcx,1)
movups 0x20(%r14,%rcx,1),%xmm2
movups 0x30(%r14,%rcx,1),%xmm3
xorps  %xmm0,%xmm2
xorps  %xmm0,%xmm3
movups %xmm2,0x20(%r12,%rcx,1)
movups %xmm3,0x30(%r12,%rcx,1)
movups 0x20(%r14,%rcx,1),%xmm2
movups 0x30(%r14,%rcx,1),%xmm3
xorps  %xmm1,%xmm2
xorps  %xmm1,%xmm3
movups %xmm2,0x20(%rbx,%rcx,1)
movups %xmm3,0x30(%rbx,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1380 <Com_HMACMD5String+0x230>
test   $0x1,%dl
je     1443 <Com_HMACMD5String+0x2f3>
movups (%r14,%rcx,1),%xmm0
movups 0x10(%r14,%rcx,1),%xmm1
movaps 0xbef(%rip),%xmm2
xorps  %xmm2,%xmm0
xorps  %xmm2,%xmm1
movups %xmm0,(%r12,%rcx,1)
movups %xmm1,0x10(%r12,%rcx,1)
movups (%r14,%rcx,1),%xmm0
movups 0x10(%r14,%rcx,1),%xmm1
movaps 0xbdc(%rip),%xmm2
xorps  %xmm2,%xmm0
xorps  %xmm2,%xmm1
movups %xmm0,(%rbx,%rcx,1)
movups %xmm1,0x10(%rbx,%rcx,1)
cmp    %r13,%rax
je     122b <Com_HMACMD5String+0xdb>
test   $0x18,%r13b
je     11bd <Com_HMACMD5String+0x6d>
mov    %rax,%rcx
mov    %r13,%rax
and    $0xfffffffffffffff8,%rax
movabs $0x5c5c5c5c5c5c5c5c,%rdx
5c 5c 5c
movabs $0x3636363636363636,%rsi
36 36 36
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r14,%rcx,1),%rdi
xor    %rdx,%rdi
mov    %rdi,(%r12,%rcx,1)
mov    (%r14,%rcx,1),%rdi
xor    %rsi,%rdi
mov    %rdi,(%rbx,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1480 <Com_HMACMD5String+0x330>
cmp    %r13,%rax
jne    11bd <Com_HMACMD5String+0x6d>
jmp    122b <Com_HMACMD5String+0xdb>
xor    %ecx,%ecx
test   $0x1,%dl
jne    13ff <Com_HMACMD5String+0x2af>
jmp    1443 <Com_HMACMD5String+0x2f3>

LLVM IR (-O0):
define i8* @Com_HMACMD5String(i8* %0, i64 %1, i8* %2, i32 %3, i8* %4, i64 %5) {
%7 = alloca i8*
%8 = alloca i64
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i64
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i8*
%16 = alloca i8*
%17 = alloca i32
%18 = alloca i32
%19 = alloca [40 x i8]
store i8* %0, i8** %7
store i64 %1, i64* %8
store i8* %2, i8** %9
store i32 %3, i32* %10
store i8* %4, i8** %11
store i64 %5, i64* %12
%20 = load i8*, i8** %7
store i8* %20, i8** %15
%21 = load i64, i64* %8
%22 = trunc i64 %21 to i32
%23 = call i8* @Z_Malloc(i32 %22)
store i8* %23, i8** %13
%24 = load i64, i64* %8
%25 = trunc i64 %24 to i32
%26 = call i8* @Z_Malloc(i32 %25)
store i8* %26, i8** %14
%27 = load i64, i64* %8
%28 = load i32, i32* %10
%29 = sext i32 %28 to i64
%30 = add i64 %27, %29
%31 = load i64, i64* %8
%32 = add i64 %31, 32
%33 = icmp ult i64 %30, %32
br i1 %33, label %34, label %37
34: ; preds = %6
%35 = load i64, i64* %8
%36 = add i64 %35, 32
br label %42
37: ; preds = %6
%38 = load i64, i64* %8
%39 = load i32, i32* %10
%40 = sext i32 %39 to i64
%41 = add i64 %38, %40
br label %42
42: ; preds = %37, %34
%43 = phi i64 [ %36, %34 ], [ %41, %37 ]
%44 = trunc i64 %43 to i32
store i32 %44, i32* %18
%45 = load i32, i32* %18
%46 = call i8* @Z_Malloc(i32 %45)
store i8* %46, i8** %16
store i32 0, i32* %17
br label %47
47: ; preds = %77, %42
%48 = load i32, i32* %17
%49 = sext i32 %48 to i64
%50 = load i64, i64* %8
%51 = icmp ult i64 %49, %50
br i1 %51, label %52, label %80
52: ; preds = %47
%53 = load i8*, i8** %15
%54 = load i32, i32* %17
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8, i8* %53, i64 %55
%57 = load i8, i8* %56
%58 = zext i8 %57 to i32
%59 = xor i32 %58, 92
%60 = trunc i32 %59 to i8
%61 = load i8*, i8** %13
%62 = load i32, i32* %17
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i8, i8* %61, i64 %63
store i8 %60, i8* %64
%65 = load i8*, i8** %15
%66 = load i32, i32* %17
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i8, i8* %65, i64 %67
%69 = load i8, i8* %68
%70 = zext i8 %69 to i32
%71 = xor i32 %70, 54
%72 = trunc i32 %71 to i8
%73 = load i8*, i8** %14
%74 = load i32, i32* %17
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %73, i64 %75
store i8 %72, i8* %76
br label %77
77: ; preds = %52
%78 = load i32, i32* %17
%79 = add nsw i32 %78, 1
store i32 %79, i32* %17
br label %47
80: ; preds = %47
%81 = load i8*, i8** %16
%82 = load i8*, i8** %14
%83 = load i64, i64* %8
%84 = call i32 (i8*, ...) @memcpy(i8* %81, i8* %82, i64 %83)
%85 = load i8*, i8** %16
%86 = load i64, i64* %8
%87 = getelementptr inbounds i8, i8* %85, i64 %86
%88 = load i8*, i8** %9
%89 = load i32, i32* %10
%90 = call i32 (i8*, ...) @memcpy(i8* %87, i8* %88, i32 %89)
%91 = load i8*, i8** %16
%92 = load i64, i64* %8
%93 = load i32, i32* %10
%94 = sext i32 %93 to i64
%95 = add i64 %92, %94
%96 = trunc i64 %95 to i32
%97 = getelementptr inbounds [40 x i8], [40 x i8]* %19, i64 0, i64 0
%98 = call i32 @Com_MD5HashString(i8* %91, i32 %96, i8* %97, i64 40)
%99 = load i8*, i8** %16
%100 = load i8*, i8** %13
%101 = load i64, i64* %8
%102 = call i32 (i8*, ...) @memcpy(i8* %99, i8* %100, i64 %101)
%103 = load i8*, i8** %16
%104 = load i64, i64* %8
%105 = getelementptr inbounds i8, i8* %103, i64 %104
%106 = getelementptr inbounds [40 x i8], [40 x i8]* %19, i64 0, i64 0
%107 = getelementptr inbounds [40 x i8], [40 x i8]* %19, i64 0, i64 0
%108 = call i64 @strlen(i8* %107)
%109 = call i32 (i8*, ...) @memcpy(i8* %105, i8* %106, i64 %108)
%110 = load i8*, i8** %16
%111 = load i64, i64* %8
%112 = getelementptr inbounds [40 x i8], [40 x i8]* %19, i64 0, i64 0
%113 = call i64 @strlen(i8* %112)
%114 = add i64 %111, %113
%115 = trunc i64 %114 to i32
%116 = load i8*, i8** %11
%117 = load i64, i64* %12
%118 = call i32 @Com_MD5HashString(i8* %110, i32 %115, i8* %116, i64 %117)
%119 = load i8*, i8** %16
%120 = call i32 @Z_Free(i8* %119)
%121 = load i8*, i8** %13
%122 = call i32 @Z_Free(i8* %121)
%123 = load i8*, i8** %14
%124 = call i32 @Z_Free(i8* %123)
%125 = load i8*, i8** %11
ret i8* %125
}

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