#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*/ MD4(unsigned char *, size_t, unsigned char *);
char checkFoundPwd(char *pwdUTF, unsigned int taille, unsigned int *hash,
                   char *pwd) {
  unsigned int i = 0;
  unsigned int hashTest[4];
  char result = 1;
  MD4((unsigned char *)pwdUTF, (size_t)(taille), (unsigned char *)hashTest);
  for (i = 0; i < 4; i++) {
    if (hash[i] != hashTest[i]) {
      result = 0;
    }
  }
  if (result) {
    for (i = 0; i < (taille >> 1); i++) {
      pwd[i] = pwdUTF[i << 1];
    }
    pwd[taille >> 1] = '\0';
  }
  return result;
}


x86 assembly (clang, -O0):
<checkFoundPwd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movb   $0x1,-0x41(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%eax
mov    %eax,%esi
lea    -0x40(%rbp),%rdx
call   1030 <MD4@plt>
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jae    1183 <checkFoundPwd+0x73>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    -0x24(%rbp),%ecx
cmp    -0x40(%rbp,%rcx,4),%eax
je     1170 <checkFoundPwd+0x60>
movb   $0x0,-0x41(%rbp)
jmp    1175 <checkFoundPwd+0x65>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    114b <checkFoundPwd+0x3b>
cmpb   $0x0,-0x41(%rbp)
je     11dc <checkFoundPwd+0xcc>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
shr    $0x1,%ecx
cmp    %ecx,%eax
jae    11cc <checkFoundPwd+0xbc>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1194 <checkFoundPwd+0x84>
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movb   $0x0,(%rax,%rcx,1)
movsbl -0x41(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<checkFoundPwd>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rcx,%r15
mov    %rdx,%rbp
mov    %esi,%r12d
mov    %rdi,%rbx
mov    %esi,%r14d
mov    %rsp,%rdx
mov    %r14,%rsi
call   1030 <MD4@plt>
movdqu 0x0(%rbp),%xmm0
pcmpeqd (%rsp),%xmm0
pslld  $0x1f,%xmm0
movmskps %xmm0,%ebp
cmp    $0xf,%bpl
jne    1204 <checkFoundPwd+0xf4>
shr    %r14
cmp    $0x2,%r12d
jb     11ff <checkFoundPwd+0xef>
cmp    $0x2,%r14d
mov    $0x1,%ecx
cmovae %r14d,%ecx
cmp    $0x9,%ecx
jb     118f <checkFoundPwd+0x7f>
lea    (%rbx,%rcx,2),%rdx
add    $0xffffffffffffffff,%rdx
cmp    %r15,%rdx
jbe    1218 <checkFoundPwd+0x108>
lea    (%r15,%rcx,1),%rdx
cmp    %rbx,%rdx
jbe    1218 <checkFoundPwd+0x108>
xor    %edx,%edx
mov    %ecx,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
and    $0x3,%rdi
je     11c2 <checkFoundPwd+0xb2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rbx,%rdx,2),%eax
mov    %al,(%r15,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    11b0 <checkFoundPwd+0xa0>
cmp    $0x3,%rsi
jb     11ff <checkFoundPwd+0xef>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rdx,2),%eax
mov    %al,(%r15,%rdx,1)
movzbl 0x2(%rbx,%rdx,2),%eax
mov    %al,0x1(%r15,%rdx,1)
movzbl 0x4(%rbx,%rdx,2),%eax
mov    %al,0x2(%r15,%rdx,1)
movzbl 0x6(%rbx,%rdx,2),%eax
mov    %al,0x3(%r15,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    11d0 <checkFoundPwd+0xc0>
movb   $0x0,(%r15,%r14,1)
cmp    $0xf,%bpl
sete   %al
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x11,%ecx
jae    1221 <checkFoundPwd+0x111>
xor    %edx,%edx
jmp    127f <checkFoundPwd+0x16f>
mov    %ecx,%edx
and    $0xf,%edx
test   %rdx,%rdx
mov    $0x10,%esi
cmovne %rdx,%rsi
mov    %rcx,%rdx
sub    %rsi,%rdx
xor    %edi,%edi
movdqa 0xdbe(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%rbx,%rdi,2),%xmm1
movdqu 0x10(%rbx,%rdi,2),%xmm2
pand   %xmm0,%xmm2
pand   %xmm0,%xmm1
packuswb %xmm2,%xmm1
movdqu %xmm1,(%r15,%rdi,1)
add    $0x10,%rdi
cmp    %rdi,%rdx
jne    1250 <checkFoundPwd+0x140>
cmp    $0x9,%esi
jb     1191 <checkFoundPwd+0x81>
mov    %rdx,%rsi
mov    %ecx,%edx
and    $0x7,%edx
test   %rdx,%rdx
mov    $0x8,%edi
cmovne %rdx,%rdi
mov    %rcx,%rdx
sub    %rdi,%rdx
movdqa 0xd5f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu (%rbx,%rsi,2),%xmm1
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%r15,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    12b0 <checkFoundPwd+0x1a0>
jmp    1191 <checkFoundPwd+0x81>

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

LLVM IR (-O2):
define signext i8 @checkFoundPwd(i8* %0, i32 %1, i32* nocapture %2, i8* nocapture writeonly %3) {
%5 = alloca <4 x i32>
%6 = bitcast <4 x i32>* %5 to i8*
%7 = zext i32 %1 to i64
%8 = call i32 @MD4(i8* %0, i64 %7, i8* %6)
%9 = bitcast i32* %2 to <4 x i32>*
%10 = load <4 x i32>, <4 x i32>* %9
%11 = load <4 x i32>, <4 x i32>* %5
%12 = icmp eq <4 x i32> %10, %11
%13 = freeze <4 x i1> %12
%14 = bitcast <4 x i1> %13 to i4
%15 = icmp eq i4 %14, -1
br i1 %15, label %16, label %114
16: ; preds = %4
%17 = lshr i32 %1, 1
%18 = icmp ult i32 %1, 2
br i1 %18, label %111, label %19
19: ; preds = %16
%20 = call i32 @llvm.umax.i32(i32 %17, i32 1)
%21 = zext i32 %20 to i64
%22 = icmp ult i32 %20, 9
br i1 %22, label %68, label %23
23: ; preds = %19
%24 = getelementptr i8, i8* %3, i64 %21
%25 = shl nuw nsw i64 %21, 1
%26 = add nsw i64 %25, -1
%27 = getelementptr i8, i8* %0, i64 %26
%28 = icmp ugt i8* %27, %3
%29 = icmp ugt i8* %24, %0
%30 = and i1 %28, %29
br i1 %30, label %68, label %31
31: ; preds = %23
%32 = icmp ult i32 %20, 17
br i1 %32, label %51, label %33
33: ; preds = %31
%34 = and i64 %21, 15
%35 = icmp eq i64 %34, 0
%36 = select i1 %35, i64 16, i64 %34
%37 = sub nsw i64 %21, %36
br label %38
38: ; preds = %38, %33
%39 = phi i64 [ 0, %33 ], [ %47, %38 ]
%40 = shl nuw i64 %39, 1
%41 = getelementptr inbounds i8, i8* %0, i64 %40
%42 = bitcast i8* %41 to <32 x i8>*
%43 = load <32 x i8>, <32 x i8>* %42
%44 = shufflevector <32 x i8> %43, <32 x i8> poison, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
%45 = getelementptr inbounds i8, i8* %3, i64 %39
%46 = bitcast i8* %45 to <16 x i8>*
store <16 x i8> %44, <16 x i8>* %46
%47 = add nuw i64 %39, 16
%48 = icmp eq i64 %47, %37
br i1 %48, label %49, label %38
49: ; preds = %38
%50 = icmp ult i64 %36, 9
br i1 %50, label %68, label %51
51: ; preds = %31, %49
%52 = phi i64 [ %37, %49 ], [ 0, %31 ]
%53 = and i64 %21, 7
%54 = icmp eq i64 %53, 0
%55 = select i1 %54, i64 8, i64 %53
%56 = sub nsw i64 %21, %55
br label %57
57: ; preds = %57, %51
%58 = phi i64 [ %52, %51 ], [ %66, %57 ]
%59 = shl nuw i64 %58, 1
%60 = getelementptr inbounds i8, i8* %0, i64 %59
%61 = bitcast i8* %60 to <16 x i8>*
%62 = load <16 x i8>, <16 x i8>* %61
%63 = shufflevector <16 x i8> %62, <16 x i8> poison, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
%64 = getelementptr inbounds i8, i8* %3, i64 %58
%65 = bitcast i8* %64 to <8 x i8>*
store <8 x i8> %63, <8 x i8>* %65
%66 = add nuw i64 %58, 8
%67 = icmp eq i64 %66, %56
br i1 %67, label %68, label %57
68: ; preds = %57, %23, %19, %49
%69 = phi i64 [ 0, %19 ], [ 0, %23 ], [ %37, %49 ], [ %56, %57 ]
%70 = sub nsw i64 %21, %69
%71 = xor i64 %69, -1
%72 = add nsw i64 %71, %21
%73 = and i64 %70, 3
%74 = icmp eq i64 %73, 0
br i1 %74, label %85, label %75
75: ; preds = %68, %75
%76 = phi i64 [ %82, %75 ], [ %69, %68 ]
%77 = phi i64 [ %83, %75 ], [ 0, %68 ]
%78 = shl nuw i64 %76, 1
%79 = getelementptr inbounds i8, i8* %0, i64 %78
%80 = load i8, i8* %79
%81 = getelementptr inbounds i8, i8* %3, i64 %76
store i8 %80, i8* %81
%82 = add nuw nsw i64 %76, 1
%83 = add i64 %77, 1
%84 = icmp eq i64 %83, %73
br i1 %84, label %85, label %75
85: ; preds = %75, %68
%86 = phi i64 [ %69, %68 ], [ %82, %75 ]
%87 = icmp ult i64 %72, 3
br i1 %87, label %111, label %88
88: ; preds = %85, %88
%89 = phi i64 [ %109, %88 ], [ %86, %85 ]
%90 = shl nuw i64 %89, 1
%91 = getelementptr inbounds i8, i8* %0, i64 %90
%92 = load i8, i8* %91
%93 = getelementptr inbounds i8, i8* %3, i64 %89
store i8 %92, i8* %93
%94 = add nuw nsw i64 %89, 1
%95 = shl nuw i64 %94, 1
%96 = getelementptr inbounds i8, i8* %0, i64 %95
%97 = load i8, i8* %96
%98 = getelementptr inbounds i8, i8* %3, i64 %94
store i8 %97, i8* %98
%99 = add nuw nsw i64 %89, 2
%100 = shl nuw i64 %99, 1
%101 = getelementptr inbounds i8, i8* %0, i64 %100
%102 = load i8, i8* %101
%103 = getelementptr inbounds i8, i8* %3, i64 %99
store i8 %102, i8* %103
%104 = add nuw nsw i64 %89, 3
%105 = shl nuw i64 %104, 1
%106 = getelementptr inbounds i8, i8* %0, i64 %105
%107 = load i8, i8* %106
%108 = getelementptr inbounds i8, i8* %3, i64 %104
store i8 %107, i8* %108
%109 = add nuw nsw i64 %89, 4
%110 = icmp eq i64 %109, %21
br i1 %110, label %111, label %88
111: ; preds = %85, %88, %16
%112 = zext i32 %17 to i64
%113 = getelementptr inbounds i8, i8* %3, i64 %112
store i8 0, i8* %113
br label %114
114: ; preds = %111, %4
%115 = zext i1 %15 to i8
ret i8 %115
}