#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*/ input();
int /*<<< orphan*/ test(int, char *, char *);
int main(void) {
  test(1, "D41D8CD98F00B204E9800998ECF8427E", "");
  test(2, "0CC175B9C0F1B6A831C399E269772661", "a");
  test(3, "900150983CD24FB0D6963F7D28E17F72", "abc");
  test(4, "F96B697D7CB7938D525A2F31AAF161D0", "message digest");
  test(5, "C3FCD3D76192E4007DFB496CCA67E13B", "abcdefghijklmnopqrstuvwxyz");
  test(6, "D174AB98D277D9F5A5611C2C9F419D9F",
       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
  test(7, "57EDF4A22BE3C955AC49DA2E2107B67A",
       "12345678901234567890123456789012345678901234567890123456789012345678901"
       "234567890");
  test(8, "9476939352B60788B64C6EAC1C504F3F", "MegaShow");
  test(9, "7193551A825044683DA074FAB296950B", "Zhenly is very vegetable.");
  test(10, "CFD15B5BF752AD3CA821C31997AFE577",
       "The MD5 message-digest algorithm is a widely used hash function "
       "producing a 128-bit hash value. Although MD5 was initially designed to "
       "be used as a cryptographic hash function, it has been found to suffer "
       "from extensive vulnerabilities. It can still be used as a checksum to "
       "verify data integrity, but only against unintentional corruption. It "
       "remains suitable for other non-cryptographic purposes, for example for "
       "determining the partition for a particular key in a partitioned "
       "database.[3]\r\nOne basic requirement of any cryptographic hash "
       "function is that it should be computationally infeasible to find two "
       "distinct messages which hash to the same value. MD5 fails this "
       "requirement catastrophically; such collisions can be found in seconds "
       "on an ordinary home computer.\r\nThe weaknesses of MD5 have been "
       "exploited in the field, most infamously by the Flame malware in 2012. "
       "The CMU Software Engineering Institute considers MD5 essentially "
       "\"cryptographically broken and unsuitable for further use\".[4]\r\nMD5 "
       "was designed by Ronald Rivest in 1991 to replace an earlier hash "
       "function MD4,[5] and was specified in 1992 as RFC 1321.");
  input();
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
mov    $0x1,%edi
lea    0xed0(%rip),%rsi
lea    0x155e(%rip),%rdx
call   1040 <test@plt>
mov    $0x2,%edi
lea    0xed9(%rip),%rsi
lea    0xef3(%rip),%rdx
call   1040 <test@plt>
mov    $0x3,%edi
lea    0xee4(%rip),%rsi
lea    0xefe(%rip),%rdx
call   1040 <test@plt>
mov    $0x4,%edi
lea    0xef1(%rip),%rsi
lea    0xf0b(%rip),%rdx
call   1040 <test@plt>
mov    $0x5,%edi
lea    0xf09(%rip),%rsi
lea    0xf23(%rip),%rdx
call   1040 <test@plt>
mov    $0x6,%edi
lea    0xf2d(%rip),%rsi
lea    0xf47(%rip),%rdx
call   1040 <test@plt>
mov    $0x7,%edi
lea    0xf75(%rip),%rsi
lea    0xf8f(%rip),%rdx
call   1040 <test@plt>
mov    $0x8,%edi
lea    0xfcf(%rip),%rsi
lea    0xfe9(%rip),%rdx
call   1040 <test@plt>
mov    $0x9,%edi
lea    0xfe1(%rip),%rsi
lea    0xffb(%rip),%rdx
call   1040 <test@plt>
mov    $0xa,%edi
lea    0x1004(%rip),%rsi
lea    0x101e(%rip),%rdx
call   1040 <test@plt>
mov    $0x0,%al
call   1030 <input@plt>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
lea    0xed8(%rip),%rsi
lea    0x1566(%rip),%rdx
mov    $0x1,%edi
call   1040 <test@plt>
lea    0xee1(%rip),%rsi
lea    0xefb(%rip),%rdx
mov    $0x2,%edi
call   1040 <test@plt>
lea    0xeec(%rip),%rsi
lea    0xf06(%rip),%rdx
mov    $0x3,%edi
call   1040 <test@plt>
lea    0xef9(%rip),%rsi
lea    0xf13(%rip),%rdx
mov    $0x4,%edi
call   1040 <test@plt>
lea    0xf11(%rip),%rsi
lea    0xf2b(%rip),%rdx
mov    $0x5,%edi
call   1040 <test@plt>
lea    0xf35(%rip),%rsi
lea    0xf4f(%rip),%rdx
mov    $0x6,%edi
call   1040 <test@plt>
lea    0xf7d(%rip),%rsi
lea    0xf97(%rip),%rdx
mov    $0x7,%edi
call   1040 <test@plt>
lea    0xfd7(%rip),%rsi
lea    0xff1(%rip),%rdx
mov    $0x8,%edi
call   1040 <test@plt>
lea    0xfe9(%rip),%rsi
lea    0x1003(%rip),%rdx
mov    $0x9,%edi
call   1040 <test@plt>
lea    0x100c(%rip),%rsi
lea    0x1026(%rip),%rdx
mov    $0xa,%edi
call   1040 <test@plt>
xor    %eax,%eax
call   1030 <input@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [33 x i8] c"D41D8CD98F00B204E9800998ECF8427E\00"
@.str.1 = [1 x i8] zeroinitializer
@.str.2 = [33 x i8] c"0CC175B9C0F1B6A831C399E269772661\00"
@.str.3 = [2 x i8] c"a\00"
@.str.4 = [33 x i8] c"900150983CD24FB0D6963F7D28E17F72\00"
@.str.5 = [4 x i8] c"abc\00"
@.str.6 = [33 x i8] c"F96B697D7CB7938D525A2F31AAF161D0\00"
@.str.7 = [15 x i8] c"message digest\00"
@.str.8 = [33 x i8] c"C3FCD3D76192E4007DFB496CCA67E13B\00"
@.str.9 = [27 x i8] c"abcdefghijklmnopqrstuvwxyz\00"
@.str.10 = [33 x i8] c"D174AB98D277D9F5A5611C2C9F419D9F\00"
@.str.11 = [63 x i8] c"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\00"
@.str.12 = [33 x i8] c"57EDF4A22BE3C955AC49DA2E2107B67A\00"
@.str.13 = [81 x i8] c"12345678901234567890123456789012345678901234567890123456789012345678901234567890\00"
@.str.14 = [33 x i8] c"9476939352B60788B64C6EAC1C504F3F\00"
@.str.15 = [9 x i8] c"MegaShow\00"
@.str.16 = [33 x i8] c"7193551A825044683DA074FAB296950B\00"
@.str.17 = [26 x i8] c"Zhenly is very vegetable.\00"
@.str.18 = [33 x i8] c"CFD15B5BF752AD3CA821C31997AFE577\00"
@.str.19 = [1129 x i8] c"The MD5 message-digest algorithm is a widely used hash function producing a 128-bit hash value. Although MD5 was initially designed to be used as a cryptographic hash function, it has been found to suffer from extensive vulnerabilities. It can still be used as a checksum to verify data integrity, but only against unintentional corruption. It remains suitable for other non-cryptographic purposes, for example for determining the partition for a particular key in a partitioned database.[3]\0D\0AOne basic requirement of any cryptographic hash function is that it should be computationally infeasible to find two distinct messages which hash to the same value. MD5 fails this requirement catastrophically; such collisions can be found in seconds on an ordinary home computer.\0D\0AThe weaknesses of MD5 have been exploited in the field, most infamously by the Flame malware in 2012. The CMU Software Engineering Institute considers MD5 essentially \22cryptographically broken and unsuitable for further use\22.[4]\0D\0AMD5 was designed by Ronald Rivest in 1991 to replace an earlier hash function MD4,[5] and was specified in 1992 as RFC 1321.\00"
define i32 @main() {
%1 = call i32 @test(i32 1, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%2 = call i32 @test(i32 2, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%3 = call i32 @test(i32 3, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0))
%4 = call i32 @test(i32 4, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0))
%5 = call i32 @test(i32 5, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.9, i64 0, i64 0))
%6 = call i32 @test(i32 6, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.11, i64 0, i64 0))
%7 = call i32 @test(i32 7, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.13, i64 0, i64 0))
%8 = call i32 @test(i32 8, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.14, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0))
%9 = call i32 @test(i32 9, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.17, i64 0, i64 0))
%10 = call i32 @test(i32 10, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.18, i64 0, i64 0), i8* getelementptr inbounds ([1129 x i8], [1129 x i8]* @.str.19, i64 0, i64 0))
%11 = call i32 (...) @input()
ret i32 0
}

LLVM IR (-O2):
@.str = [33 x i8] c"D41D8CD98F00B204E9800998ECF8427E\00"
@.str.1 = [1 x i8] zeroinitializer
@.str.2 = [33 x i8] c"0CC175B9C0F1B6A831C399E269772661\00"
@.str.3 = [2 x i8] c"a\00"
@.str.4 = [33 x i8] c"900150983CD24FB0D6963F7D28E17F72\00"
@.str.5 = [4 x i8] c"abc\00"
@.str.6 = [33 x i8] c"F96B697D7CB7938D525A2F31AAF161D0\00"
@.str.7 = [15 x i8] c"message digest\00"
@.str.8 = [33 x i8] c"C3FCD3D76192E4007DFB496CCA67E13B\00"
@.str.9 = [27 x i8] c"abcdefghijklmnopqrstuvwxyz\00"
@.str.10 = [33 x i8] c"D174AB98D277D9F5A5611C2C9F419D9F\00"
@.str.11 = [63 x i8] c"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\00"
@.str.12 = [33 x i8] c"57EDF4A22BE3C955AC49DA2E2107B67A\00"
@.str.13 = [81 x i8] c"12345678901234567890123456789012345678901234567890123456789012345678901234567890\00"
@.str.14 = [33 x i8] c"9476939352B60788B64C6EAC1C504F3F\00"
@.str.15 = [9 x i8] c"MegaShow\00"
@.str.16 = [33 x i8] c"7193551A825044683DA074FAB296950B\00"
@.str.17 = [26 x i8] c"Zhenly is very vegetable.\00"
@.str.18 = [33 x i8] c"CFD15B5BF752AD3CA821C31997AFE577\00"
@.str.19 = [1129 x i8] c"The MD5 message-digest algorithm is a widely used hash function producing a 128-bit hash value. Although MD5 was initially designed to be used as a cryptographic hash function, it has been found to suffer from extensive vulnerabilities. It can still be used as a checksum to verify data integrity, but only against unintentional corruption. It remains suitable for other non-cryptographic purposes, for example for determining the partition for a particular key in a partitioned database.[3]\0D\0AOne basic requirement of any cryptographic hash function is that it should be computationally infeasible to find two distinct messages which hash to the same value. MD5 fails this requirement catastrophically; such collisions can be found in seconds on an ordinary home computer.\0D\0AThe weaknesses of MD5 have been exploited in the field, most infamously by the Flame malware in 2012. The CMU Software Engineering Institute considers MD5 essentially \22cryptographically broken and unsuitable for further use\22.[4]\0D\0AMD5 was designed by Ronald Rivest in 1991 to replace an earlier hash function MD4,[5] and was specified in 1992 as RFC 1321.\00"
define i32 @main() {
%1 = tail call i32 @test(i32 1, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%2 = tail call i32 @test(i32 2, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%3 = tail call i32 @test(i32 3, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0))
%4 = tail call i32 @test(i32 4, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i64 0, i64 0))
%5 = tail call i32 @test(i32 5, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.9, i64 0, i64 0))
%6 = tail call i32 @test(i32 6, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.11, i64 0, i64 0))
%7 = tail call i32 @test(i32 7, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.13, i64 0, i64 0))
%8 = tail call i32 @test(i32 8, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.14, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0))
%9 = tail call i32 @test(i32 9, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.17, i64 0, i64 0))
%10 = tail call i32 @test(i32 10, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.18, i64 0, i64 0), i8* getelementptr inbounds ([1129 x i8], [1129 x i8]* @.str.19, i64 0, i64 0))
%11 = tail call i32 (...) @input()
ret i32 0
}