#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 int64_t;

/* Variables and functions */
int floor(int);
int /*<<< orphan*/ free(char *);
int log(int);
scalar_t__ malloc(int);
int pow(int, int);
int /*<<< orphan*/ sha256(char *, int, char *);
scalar_t__ strcmp(char const *, int /*<<< orphan*/);
int strlen(char const *);
int /*<<< orphan*/ strncpy(char *, char *, int);
char *reverse_sha256(const char *hash, int min_length, int max_length,
                     const char *character_set) {
  int character_set_length = strlen(character_set), str_length;
  char *str_hash;
  char *str;
  int i, t, range;
  int64_t id, remainder;
  int64_t max_id = pow(character_set_length, max_length);
  int done = 0;
  char *result = NULL;
#pragma omp parallel private(id, i, t, range, remainder, str, str_hash)
  {
    str_hash = (char *)malloc(65 * sizeof(char));
    str = (char *)malloc((max_length + 1) * sizeof(char));
    str[max_length] = '\0';
#pragma omp for schedule(dynamic)
    for (id = 0; id < max_id; ++id) {
#pragma omp flush(done)
      if (done)
        continue;
      str_length =
          id == 0 ? 0 : (floor(log(id) / log(character_set_length)) + 1);
      t = 2 * max_length - str_length - 1;
      for (i = 0; i < max_length - str_length; ++i)
        str[i] = character_set[0];
      for (remainder = id; remainder && i < max_length; ++i) {
        str[t - i] = character_set[remainder % character_set_length];
        remainder /= character_set_length;
      }
      range = max_length - (str_length > min_length ? str_length : min_length);
      for (i = 0; i <= range; ++i) {
        if (strcmp(hash, sha256(str + i, max_length - i, str_hash)) == 0) {
          result = (char *)malloc((max_length - i + 1) * sizeof(char));
          strncpy(result, str + i, max_length - i);
          result[max_length - i] = '\0';
          done = 1;
          break;
        }
      }
    }
    free(str_hash);
    free(str);
  }
  return result;
}


x86 assembly (clang, -O0):
<reverse_sha256>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%edi
mov    -0x10(%rbp),%esi
call   10a0 <pow@plt>
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movq   $0x0,-0x58(%rbp)
mov    $0x41,%edi
call   1080 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1410 <reverse_sha256+0x280>
cmpl   $0x0,-0x4c(%rbp)
je     1225 <reverse_sha256+0x95>
jmp    1402 <reverse_sha256+0x272>
cmpl   $0x0,-0x40(%rbp)
jne    1239 <reverse_sha256+0xa9>
xor    %eax,%eax
mov    %eax,-0x5c(%rbp)
jmp    1261 <reverse_sha256+0xd1>
mov    -0x40(%rbp),%edi
call   1090 <log@plt>
mov    %eax,-0x60(%rbp)
mov    -0x1c(%rbp),%edi
call   1090 <log@plt>
mov    %eax,%ecx
mov    -0x60(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,%edi
call   10b0 <floor@plt>
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
shl    $0x1,%eax
sub    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    12ad <reverse_sha256+0x11d>
mov    -0x18(%rbp),%rax
mov    (%rax),%dl
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    127d <reverse_sha256+0xed>
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x44(%rbp)
mov    %al,-0x61(%rbp)
je     12ce <reverse_sha256+0x13e>
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
setl   %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    12de <reverse_sha256+0x14e>
jmp    1321 <reverse_sha256+0x191>
mov    -0x18(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x44(%rbp),%eax
cltd
idivl  -0x1c(%rbp)
mov    -0x70(%rbp),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%ecx
mov    -0x44(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12b3 <reverse_sha256+0x123>
mov    -0x10(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    133e <reverse_sha256+0x1ae>
mov    -0x20(%rbp),%eax
mov    %eax,-0x78(%rbp)
jmp    1344 <reverse_sha256+0x1b4>
mov    -0xc(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x78(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     13fd <reverse_sha256+0x26d>
mov    -0x8(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x30(%rbp),%rdi
movslq -0x34(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%esi
sub    -0x34(%rbp),%esi
mov    -0x28(%rbp),%rdx
call   1060 <sha256@plt>
mov    -0x80(%rbp),%rdi
mov    %eax,%esi
call   1070 <strcmp@plt>
cmp    $0x0,%rax
jne    13ea <reverse_sha256+0x25a>
mov    -0x10(%rbp),%eax
sub    -0x34(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x30(%rbp),%rsi
movslq -0x34(%rbp),%rax
add    %rax,%rsi
mov    -0x10(%rbp),%edx
sub    -0x34(%rbp),%edx
call   1040 <strncpy@plt>
mov    -0x58(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x1,-0x4c(%rbp)
jmp    13fd <reverse_sha256+0x26d>
jmp    13ef <reverse_sha256+0x25f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1356 <reverse_sha256+0x1c6>
jmp    1402 <reverse_sha256+0x272>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    120a <reverse_sha256+0x7a>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reverse_sha256>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,%rbx
mov    %edx,%ebp
mov    %esi,0x24(%rsp)
mov    %rdi,0x40(%rsp)
mov    %rcx,%rdi
call   1050 <strlen@plt>
mov    %eax,(%rsp)
mov    %eax,%edi
mov    %ebp,%esi
call   10a0 <pow@plt>
mov    %eax,%r15d
mov    $0x41,%edi
call   1080 <malloc@plt>
mov    %rax,0x28(%rsp)
lea    0x1(%rbp),%edi
mov    %edi,0x20(%rsp)
call   1080 <malloc@plt>
mov    %rbp,%r10
mov    %rax,%r13
movslq %r10d,%rax
mov    %rax,0x38(%rsp)
movb   $0x0,0x0(%r13,%rax,1)
xor    %ecx,%ecx
test   %r15d,%r15d
jle    14b7 <reverse_sha256+0x327>
lea    0x1(%rbx),%rax
mov    %rax,0x30(%rsp)
lea    (%r10,%r10,1),%eax
add    $0xffffffff,%eax
mov    %eax,0x1c(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
xor    %r14d,%r14d
mov    %r10,0x10(%rsp)
mov    (%rsp),%ebp
mov    %r15d,0x4(%rsp)
jmp    127d <reverse_sha256+0xed>
lea    0x1(%r12),%edi
call   1080 <malloc@plt>
mov    %rax,%rbp
mov    %rax,%rdi
mov    %r15,%rsi
mov    %r12d,%edx
call   1040 <strncpy@plt>
movslq %r12d,%rax
mov    %rbp,%rcx
mov    %rbp,0x8(%rsp)
movb   $0x0,0x0(%rbp,%rax,1)
mov    0x10(%rsp),%r10
mov    (%rsp),%ebp
mov    0x4(%rsp),%r15d
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14d
cmp    %r15d,%r14d
je     14be <reverse_sha256+0x32e>
mov    %ecx,%eax
mov    $0x1,%ecx
test   %eax,%eax
jne    1270 <reverse_sha256+0xe0>
xor    %r12d,%r12d
mov    $0x0,%r9d
test   %r14d,%r14d
je     12c3 <reverse_sha256+0x133>
mov    %r14d,%edi
call   1090 <log@plt>
mov    %eax,%r15d
mov    %ebp,%edi
call   1090 <log@plt>
mov    %eax,%ecx
mov    %r15d,%eax
cltd
idiv   %ecx
mov    %eax,%edi
call   10b0 <floor@plt>
mov    0x10(%rsp),%r10
mov    %eax,%r9d
add    $0x1,%r9d
mov    %r10d,%r8d
sub    %r9d,%r8d
test   %r8d,%r8d
mov    0x38(%rsp),%r11
jle    13fc <reverse_sha256+0x26c>
cmp    %r13,0x30(%rsp)
seta   %dl
mov    %r8d,%eax
lea    (%rax,%r13,1),%rsi
cmp    %rbx,%rsi
seta   %dil
cmp    $0x8,%r8d
jb     130b <reverse_sha256+0x17b>
mov    $0x0,%esi
and    %dil,%dl
jne    1398 <reverse_sha256+0x208>
cmp    $0x20,%r8d
jae    1312 <reverse_sha256+0x182>
xor    %esi,%esi
jmp    1354 <reverse_sha256+0x1c4>
xor    %esi,%esi
jmp    1398 <reverse_sha256+0x208>
mov    %eax,%esi
and    $0xffffffe0,%esi
movzbl (%rbx),%edx
movd   %edx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
xor    %edx,%edx
xchg   %ax,%ax
movdqu %xmm0,0x0(%r13,%rdx,1)
movdqu %xmm0,0x10(%r13,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1330 <reverse_sha256+0x1a0>
cmp    %rax,%rsi
je     13f9 <reverse_sha256+0x269>
test   $0x18,%al
je     1398 <reverse_sha256+0x208>
mov    %rsi,%rbp
mov    %r10d,%edi
sub    %r9d,%edi
mov    %edi,%esi
and    $0xfffffff8,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rbx),%edx
movd   %edx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
movq   %xmm0,0x0(%r13,%rbp,1)
add    $0x8,%rbp
cmp    %rbp,%rsi
jne    1370 <reverse_sha256+0x1e0>
cmp    %rdi,%rsi
mov    (%rsp),%ebp
je     13f9 <reverse_sha256+0x269>
mov    %rsi,%rdi
not    %rdi
add    %rax,%rdi
mov    %rax,%rdx
and    $0x3,%rdx
je     13c2 <reverse_sha256+0x232>
nopw   0x0(%rax,%rax,1)
movzbl (%rbx),%ecx
mov    %cl,0x0(%r13,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    13b0 <reverse_sha256+0x220>
cmp    $0x3,%rdi
jb     13f9 <reverse_sha256+0x269>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx),%ecx
mov    %cl,0x0(%r13,%rsi,1)
movzbl (%rbx),%ecx
mov    %cl,0x1(%r13,%rsi,1)
movzbl (%rbx),%ecx
mov    %cl,0x2(%r13,%rsi,1)
movzbl (%rbx),%ecx
mov    %cl,0x3(%r13,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%rax
jne    13d0 <reverse_sha256+0x240>
mov    %r8d,%r12d
test   %r14d,%r14d
je     1445 <reverse_sha256+0x2b5>
cmp    %r10d,%r12d
jge    1445 <reverse_sha256+0x2b5>
mov    %r12d,%esi
mov    0x1c(%rsp),%edi
sub    %r12d,%edi
sub    %r9d,%edi
add    $0x1,%rsi
mov    %r14d,%eax
nopw   0x0(%rax,%rax,1)
cltd
idiv   %ebp
movslq %edx,%rcx
movzbl (%rbx,%rcx,1),%ecx
movslq %edi,%rdx
mov    %cl,0x0(%r13,%rdx,1)
test   %eax,%eax
je     1445 <reverse_sha256+0x2b5>
add    $0xffffffff,%edi
lea    0x1(%rsi),%rcx
cmp    %r11,%rsi
mov    %rcx,%rsi
jl     1420 <reverse_sha256+0x290>
mov    0x24(%rsp),%eax
cmp    %eax,%r9d
cmovle %eax,%r9d
cmp    %r10d,%r9d
jle    1459 <reverse_sha256+0x2c9>
xor    %ecx,%ecx
jmp    14ad <reverse_sha256+0x31d>
mov    0x20(%rsp),%eax
mov    %eax,%ebp
sub    %r9d,%ebp
mov    %r13,%r15
mov    %r10d,%r12d
nopl   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %r12d,%esi
mov    0x28(%rsp),%rdx
call   1060 <sha256@plt>
mov    0x40(%rsp),%rdi
mov    %eax,%esi
call   1070 <strcmp@plt>
test   %rax,%rax
je     122a <reverse_sha256+0x9a>
add    $0xffffffff,%r12d
add    $0x1,%r15
add    $0xffffffffffffffff,%rbp
jne    1470 <reverse_sha256+0x2e0>
xor    %ecx,%ecx
mov    0x10(%rsp),%r10
mov    (%rsp),%ebp
mov    0x4(%rsp),%r15d
jmp    1270 <reverse_sha256+0xe0>
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i8* @reverse_sha256(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 i32
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i8*
store i8* %0, i8** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i8* %3, i8** %8
%21 = load i8*, i8** %8
%22 = call i32 @strlen(i8* %21)
store i32 %22, i32* %9
%23 = load i32, i32* %9
%24 = load i32, i32* %7
%25 = call i32 @pow(i32 %23, i32 %24)
store i32 %25, i32* %18
store i32 0, i32* %19
store i8* null, i8** %20
%26 = call i64 @malloc(i32 65)
%27 = inttoptr i64 %26 to i8*
store i8* %27, i8** %11
%28 = load i32, i32* %7
%29 = add nsw i32 %28, 1
%30 = sext i32 %29 to i64
%31 = mul i64 %30, 1
%32 = trunc i64 %31 to i32
%33 = call i64 @malloc(i32 %32)
%34 = inttoptr i64 %33 to i8*
store i8* %34, i8** %12
%35 = load i8*, i8** %12
%36 = load i32, i32* %7
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %35, i64 %37
store i8 0, i8* %38
store i32 0, i32* %16
br label %39
39: ; preds = %173, %4
%40 = load i32, i32* %16
%41 = load i32, i32* %18
%42 = icmp slt i32 %40, %41
br i1 %42, label %43, label %176
43: ; preds = %39
%44 = load i32, i32* %19
%45 = icmp ne i32 %44, 0
br i1 %45, label %46, label %47
46: ; preds = %43
br label %173
47: ; preds = %43
%48 = load i32, i32* %16
%49 = icmp eq i32 %48, 0
br i1 %49, label %50, label %51
50: ; preds = %47
br label %59
51: ; preds = %47
%52 = load i32, i32* %16
%53 = call i32 @log(i32 %52)
%54 = load i32, i32* %9
%55 = call i32 @log(i32 %54)
%56 = sdiv i32 %53, %55
%57 = call i32 @floor(i32 %56)
%58 = add nsw i32 %57, 1
br label %59
59: ; preds = %51, %50
%60 = phi i32 [ 0, %50 ], [ %58, %51 ]
store i32 %60, i32* %10
%61 = load i32, i32* %7
%62 = mul nsw i32 2, %61
%63 = load i32, i32* %10
%64 = sub nsw i32 %62, %63
%65 = sub nsw i32 %64, 1
store i32 %65, i32* %14
store i32 0, i32* %13
br label %66
66: ; preds = %80, %59
%67 = load i32, i32* %13
%68 = load i32, i32* %7
%69 = load i32, i32* %10
%70 = sub nsw i32 %68, %69
%71 = icmp slt i32 %67, %70
br i1 %71, label %72, label %83
72: ; preds = %66
%73 = load i8*, i8** %8
%74 = getelementptr inbounds i8, i8* %73, i64 0
%75 = load i8, i8* %74
%76 = load i8*, i8** %12
%77 = load i32, i32* %13
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i8, i8* %76, i64 %78
store i8 %75, i8* %79
br label %80
80: ; preds = %72
%81 = load i32, i32* %13
%82 = add nsw i32 %81, 1
store i32 %82, i32* %13
br label %66
83: ; preds = %66
%84 = load i32, i32* %16
store i32 %84, i32* %17
br label %85
85: ; preds = %111, %83
%86 = load i32, i32* %17
%87 = icmp ne i32 %86, 0
br i1 %87, label %88, label %92
88: ; preds = %85
%89 = load i32, i32* %13
%90 = load i32, i32* %7
%91 = icmp slt i32 %89, %90
br label %92
92: ; preds = %88, %85
%93 = phi i1 [ false, %85 ], [ %91, %88 ]
br i1 %93, label %94, label %114
94: ; preds = %92
%95 = load i8*, i8** %8
%96 = load i32, i32* %17
%97 = load i32, i32* %9
%98 = srem i32 %96, %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %95, i64 %99
%101 = load i8, i8* %100
%102 = load i8*, i8** %12
%103 = load i32, i32* %14
%104 = load i32, i32* %13
%105 = sub nsw i32 %103, %104
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %102, i64 %106
store i8 %101, i8* %107
%108 = load i32, i32* %9
%109 = load i32, i32* %17
%110 = sdiv i32 %109, %108
store i32 %110, i32* %17
br label %111
111: ; preds = %94
%112 = load i32, i32* %13
%113 = add nsw i32 %112, 1
store i32 %113, i32* %13
br label %85
114: ; preds = %92
%115 = load i32, i32* %7
%116 = load i32, i32* %10
%117 = load i32, i32* %6
%118 = icmp sgt i32 %116, %117
br i1 %118, label %119, label %121
119: ; preds = %114
%120 = load i32, i32* %10
br label %123
121: ; preds = %114
%122 = load i32, i32* %6
br label %123
123: ; preds = %121, %119
%124 = phi i32 [ %120, %119 ], [ %122, %121 ]
%125 = sub nsw i32 %115, %124
store i32 %125, i32* %15
store i32 0, i32* %13
br label %126
126: ; preds = %169, %123
%127 = load i32, i32* %13
%128 = load i32, i32* %15
%129 = icmp sle i32 %127, %128
br i1 %129, label %130, label %172
130: ; preds = %126
%131 = load i8*, i8** %5
%132 = load i8*, i8** %12
%133 = load i32, i32* %13
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i8, i8* %132, i64 %134
%136 = load i32, i32* %7
%137 = load i32, i32* %13
%138 = sub nsw i32 %136, %137
%139 = load i8*, i8** %11
%140 = call i32 @sha256(i8* %135, i32 %138, i8* %139)
%141 = call i64 @strcmp(i8* %131, i32 %140)
%142 = icmp eq i64 %141, 0
br i1 %142, label %143, label %168
143: ; preds = %130
%144 = load i32, i32* %7
%145 = load i32, i32* %13
%146 = sub nsw i32 %144, %145
%147 = add nsw i32 %146, 1
%148 = sext i32 %147 to i64
%149 = mul i64 %148, 1
%150 = trunc i64 %149 to i32
%151 = call i64 @malloc(i32 %150)
%152 = inttoptr i64 %151 to i8*
store i8* %152, i8** %20
%153 = load i8*, i8** %20
%154 = load i8*, i8** %12
%155 = load i32, i32* %13
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i8, i8* %154, i64 %156
%158 = load i32, i32* %7
%159 = load i32, i32* %13
%160 = sub nsw i32 %158, %159
%161 = call i32 @strncpy(i8* %153, i8* %157, i32 %160)
%162 = load i8*, i8** %20
%163 = load i32, i32* %7
%164 = load i32, i32* %13
%165 = sub nsw i32 %163, %164
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds i8, i8* %162, i64 %166
store i8 0, i8* %167
store i32 1, i32* %19
br label %172
168: ; preds = %130
br label %169
169: ; preds = %168
%170 = load i32, i32* %13
%171 = add nsw i32 %170, 1
store i32 %171, i32* %13
br label %126
172: ; preds = %143, %126
br label %173
173: ; preds = %172, %46
%174 = load i32, i32* %16
%175 = add nsw i32 %174, 1
store i32 %175, i32* %16
br label %39
176: ; preds = %39
%177 = load i8*, i8** %11
%178 = call i32 @free(i8* %177)
%179 = load i8*, i8** %12
%180 = call i32 @free(i8* %179)
%181 = load i8*, i8** %20
ret i8* %181
}

LLVM IR (-O2):
define i8* @reverse_sha256(i8* %0, i32 %1, i32 %2, i8* %3) {
%5 = tail call i32 @strlen(i8* %3)
%6 = tail call i32 @pow(i32 %5, i32 %2)
%7 = tail call i64 @malloc(i32 65)
%8 = inttoptr i64 %7 to i8*
%9 = add i32 %2, 1
%10 = tail call i64 @malloc(i32 %9)
%11 = inttoptr i64 %10 to i8*
%12 = sext i32 %2 to i64
%13 = getelementptr inbounds i8, i8* %11, i64 %12
store i8 0, i8* %13
%14 = icmp sgt i32 %6, 0
br i1 %14, label %15, label %168
15: ; preds = %4
%16 = shl nsw i32 %2, 1
%17 = getelementptr i8, i8* %3, i64 1
%18 = icmp ugt i8* %17, %11
br label %19
19: ; preds = %15, %163
%20 = phi i8* [ null, %15 ], [ %165, %163 ]
%21 = phi i32 [ 0, %15 ], [ %164, %163 ]
%22 = phi i32 [ 0, %15 ], [ %166, %163 ]
%23 = icmp eq i32 %21, 0
br i1 %23, label %24, label %163
24: ; preds = %19
%25 = icmp eq i32 %22, 0
br i1 %25, label %32, label %26
26: ; preds = %24
%27 = tail call i32 @log(i32 %22)
%28 = tail call i32 @log(i32 %5)
%29 = sdiv i32 %27, %28
%30 = tail call i32 @floor(i32 %29)
%31 = add nsw i32 %30, 1
br label %32
32: ; preds = %24, %26
%33 = phi i32 [ %31, %26 ], [ 0, %24 ]
%34 = xor i32 %33, -1
%35 = add i32 %16, %34
%36 = sub i32 %2, %33
%37 = icmp sgt i32 %36, 0
br i1 %37, label %38, label %100
38: ; preds = %32
%39 = zext i32 %36 to i64
%40 = icmp ult i32 %36, 8
%41 = getelementptr i8, i8* %11, i64 %39
%42 = icmp ugt i8* %41, %3
%43 = and i1 %18, %42
%44 = select i1 %40, i1 true, i1 %43
br i1 %44, label %83, label %45
45: ; preds = %38
%46 = icmp ult i32 %36, 32
br i1 %46, label %67, label %47
47: ; preds = %45
%48 = and i64 %39, 4294967264
%49 = load i8, i8* %3
%50 = insertelement <16 x i8> poison, i8 %49, i64 0
%51 = shufflevector <16 x i8> %50, <16 x i8> poison, <16 x i32> zeroinitializer
%52 = insertelement <16 x i8> poison, i8 %49, i64 0
%53 = shufflevector <16 x i8> %52, <16 x i8> poison, <16 x i32> zeroinitializer
br label %54
54: ; preds = %54, %47
%55 = phi i64 [ 0, %47 ], [ %60, %54 ]
%56 = getelementptr inbounds i8, i8* %11, i64 %55
%57 = bitcast i8* %56 to <16 x i8>*
store <16 x i8> %51, <16 x i8>* %57
%58 = getelementptr inbounds i8, i8* %56, i64 16
%59 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %53, <16 x i8>* %59
%60 = add nuw i64 %55, 32
%61 = icmp eq i64 %60, %48
br i1 %61, label %62, label %54
62: ; preds = %54
%63 = icmp eq i64 %48, %39
br i1 %63, label %100, label %64
64: ; preds = %62
%65 = and i64 %39, 24
%66 = icmp eq i64 %65, 0
br i1 %66, label %83, label %67
67: ; preds = %45, %64
%68 = phi i64 [ %48, %64 ], [ 0, %45 ]
%69 = sub i32 %2, %33
%70 = zext i32 %69 to i64
%71 = and i64 %70, 4294967288
br label %72
72: ; preds = %72, %67
%73 = phi i64 [ %68, %67 ], [ %79, %72 ]
%74 = load i8, i8* %3
%75 = insertelement <8 x i8> poison, i8 %74, i64 0
%76 = shufflevector <8 x i8> %75, <8 x i8> poison, <8 x i32> zeroinitializer
%77 = getelementptr inbounds i8, i8* %11, i64 %73
%78 = bitcast i8* %77 to <8 x i8>*
store <8 x i8> %76, <8 x i8>* %78
%79 = add nuw i64 %73, 8
%80 = icmp eq i64 %79, %71
br i1 %80, label %81, label %72
81: ; preds = %72
%82 = icmp eq i64 %71, %70
br i1 %82, label %100, label %83
83: ; preds = %38, %64, %81
%84 = phi i64 [ 0, %38 ], [ %48, %64 ], [ %71, %81 ]
%85 = xor i64 %84, -1
%86 = add nsw i64 %85, %39
%87 = and i64 %39, 3
%88 = icmp eq i64 %87, 0
br i1 %88, label %97, label %89
89: ; preds = %83, %89
%90 = phi i64 [ %94, %89 ], [ %84, %83 ]
%91 = phi i64 [ %95, %89 ], [ 0, %83 ]
%92 = load i8, i8* %3
%93 = getelementptr inbounds i8, i8* %11, i64 %90
store i8 %92, i8* %93
%94 = add nuw nsw i64 %90, 1
%95 = add i64 %91, 1
%96 = icmp eq i64 %95, %87
br i1 %96, label %97, label %89
97: ; preds = %89, %83
%98 = phi i64 [ %84, %83 ], [ %94, %89 ]
%99 = icmp ult i64 %86, 3
br i1 %99, label %100, label %107
100: ; preds = %97, %107, %62, %81, %32
%101 = phi i32 [ 0, %32 ], [ %36, %81 ], [ %36, %62 ], [ %36, %107 ], [ %36, %97 ]
%102 = icmp ne i32 %22, 0
%103 = icmp slt i32 %101, %2
%104 = select i1 %102, i1 %103, i1 false
br i1 %104, label %105, label %138
105: ; preds = %100
%106 = zext i32 %101 to i64
br label %122
107: ; preds = %97, %107
%108 = phi i64 [ %120, %107 ], [ %98, %97 ]
%109 = load i8, i8* %3
%110 = getelementptr inbounds i8, i8* %11, i64 %108
store i8 %109, i8* %110
%111 = add nuw nsw i64 %108, 1
%112 = load i8, i8* %3
%113 = getelementptr inbounds i8, i8* %11, i64 %111
store i8 %112, i8* %113
%114 = add nuw nsw i64 %108, 2
%115 = load i8, i8* %3
%116 = getelementptr inbounds i8, i8* %11, i64 %114
store i8 %115, i8* %116
%117 = add nuw nsw i64 %108, 3
%118 = load i8, i8* %3
%119 = getelementptr inbounds i8, i8* %11, i64 %117
store i8 %118, i8* %119
%120 = add nuw nsw i64 %108, 4
%121 = icmp eq i64 %120, %39
br i1 %121, label %100, label %107
122: ; preds = %105, %122
%123 = phi i64 [ %106, %105 ], [ %134, %122 ]
%124 = phi i32 [ %22, %105 ], [ %133, %122 ]
%125 = srem i32 %124, %5
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i8, i8* %3, i64 %126
%128 = load i8, i8* %127
%129 = trunc i64 %123 to i32
%130 = sub i32 %35, %129
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i8, i8* %11, i64 %131
store i8 %128, i8* %132
%133 = sdiv i32 %124, %5
%134 = add nuw nsw i64 %123, 1
%135 = icmp ne i32 %133, 0
%136 = icmp slt i64 %134, %12
%137 = select i1 %135, i1 %136, i1 false
br i1 %137, label %122, label %138
138: ; preds = %122, %100
%139 = icmp sgt i32 %33, %1
%140 = select i1 %139, i32 %33, i32 %1
%141 = icmp sgt i32 %140, %2
br i1 %141, label %163, label %142
142: ; preds = %138
%143 = sub i32 %9, %140
%144 = zext i32 %143 to i64
br label %148
145: ; preds = %148
%146 = add nuw nsw i64 %149, 1
%147 = icmp eq i64 %146, %144
br i1 %147, label %163, label %148
148: ; preds = %142, %145
%149 = phi i64 [ 0, %142 ], [ %146, %145 ]
%150 = getelementptr inbounds i8, i8* %11, i64 %149
%151 = trunc i64 %149 to i32
%152 = sub nsw i32 %2, %151
%153 = tail call i32 @sha256(i8* %150, i32 %152, i8* %8)
%154 = tail call i64 @strcmp(i8* %0, i32 %153)
%155 = icmp eq i64 %154, 0
br i1 %155, label %156, label %145
156: ; preds = %148
%157 = add nsw i32 %152, 1
%158 = tail call i64 @malloc(i32 %157)
%159 = inttoptr i64 %158 to i8*
%160 = tail call i32 @strncpy(i8* %159, i8* %150, i32 %152)
%161 = sext i32 %152 to i64
%162 = getelementptr inbounds i8, i8* %159, i64 %161
store i8 0, i8* %162
br label %163
163: ; preds = %145, %138, %156, %19
%164 = phi i32 [ 1, %19 ], [ 1, %156 ], [ 0, %138 ], [ 0, %145 ]
%165 = phi i8* [ %20, %19 ], [ %159, %156 ], [ %20, %138 ], [ %20, %145 ]
%166 = add nuw nsw i32 %22, 1
%167 = icmp eq i32 %166, %6
br i1 %167, label %168, label %19
168: ; preds = %163, %4
%169 = phi i8* [ null, %4 ], [ %165, %163 ]
%170 = tail call i32 @free(i8* %8)
%171 = tail call i32 @free(i8* %11)
ret i8* %169
}