#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 scalar_t__ uint32_t;

/* Variables and functions */
int /*<<< orphan*/ addBytes(char *, int, int /*<<< orphan*/);
scalar_t__ blocksCount(char *);
int /*<<< orphan*/ changeByte(char *, int, char);
int /*<<< orphan*/ checkFileSize(char *, char *, int);
int /*<<< orphan*/ cleanup();
int /*<<< orphan*/ createZeroFile(char *, int);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ syncAndCheckMd4(char *, char *, char *, int,
                                   int /*<<< orphan*/);
void testSparse() {
  cleanup();
  uint32_t sparseFailCount = 0;
  createZeroFile("testSource.bin", 1024 * 1024 * 5);
  uint32_t sourceBlocksCount = blocksCount("testSource.bin");
  syncAndCheckMd4("recreated source to zero", "testSource.bin", "testDest.bin",
                  1, 0);
  checkFileSize("recreated source to zero size", "testDest.bin",
                1024 * 1024 * 5);
  uint32_t destBlocksCount = blocksCount("testDest.bin");
  if (destBlocksCount >= sourceBlocksCount) {
    sparseFailCount++;
  }
  changeByte("testSource.bin", 5, 'c');
  syncAndCheckMd4("changed byte (SPARSE) ", "testSource.bin", "testDest.bin", 1,
                  0);
  checkFileSize("changed byte (SPARSE) (size)", "testDest.bin",
                1024 * 1024 * 5);
  destBlocksCount = blocksCount("testDest.bin");
  if (destBlocksCount >= sourceBlocksCount) {
    sparseFailCount++;
  }
  changeByte("testSource.bin", 5, 0);
  syncAndCheckMd4("changed byte to zero (SPARSE) ", "testSource.bin",
                  "testDest.bin", 1, 0);
  checkFileSize("changed byte to zero (SPARSE) (size)", "testDest.bin",
                1024 * 1024 * 5);
  destBlocksCount = blocksCount("testDest.bin");
  if (destBlocksCount >= sourceBlocksCount) {
    sparseFailCount++;
  }
  addBytes("testSource.bin", 5 * 1024 * 1024, 0);
  sourceBlocksCount = blocksCount("testSource.bin");
  syncAndCheckMd4("added 5 md (SPARSE) ", "testSource.bin", "testDest.bin", 1,
                  0);
  checkFileSize("added 5 md (SPARSE) (size)", "testDest.bin", 1024 * 1024 * 10);
  destBlocksCount = blocksCount("testDest.bin");
  if (destBlocksCount >= sourceBlocksCount) {
    sparseFailCount++;
  }
  changeByte("testSource.bin", 7 * 1024 * 1024, 'c');
  syncAndCheckMd4("changed one byte (SPARSE) ", "testSource.bin",
                  "testDest.bin", 1, 0);
  checkFileSize("changed one byte (SPARSE) (size)", "testDest.bin",
                1024 * 1024 * 10);
  destBlocksCount = blocksCount("testDest.bin");
  if (destBlocksCount >= sourceBlocksCount) {
    sparseFailCount++;
  }
  if (sparseFailCount > 0) {
    printf("\n  Warning: sparse mode was enabled, but the destination file "
           "doesn't seem\n"
           "  to occupy less disk space then the original file. For certain "
           "file systems it's\n"
           "  okay as they don't support sparse files.\n\n"
           "  This warning is safe, sparse files support is NOT required for "
           "data integrity.\n\n");
  }
}


x86 assembly (clang, -O0):
<testSparse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    $0x0,%al
call   1090 <cleanup@plt>
movq   $0x0,-0x8(%rbp)
lea    0xe62(%rip),%rdi
mov    $0x500000,%esi
call   1060 <createZeroFile@plt>
lea    0xe51(%rip),%rdi
call   1070 <blocksCount@plt>
mov    %rax,-0x10(%rbp)
lea    0xe50(%rip),%rdi
lea    0xe3a(%rip),%rsi
lea    0xe5b(%rip),%rdx
mov    $0x1,%ecx
xor    %r8d,%r8d
call   1080 <syncAndCheckMd4@plt>
lea    0xe54(%rip),%rdi
lea    0xe40(%rip),%rsi
mov    $0x500000,%edx
call   1030 <checkFileSize@plt>
lea    0xe2f(%rip),%rdi
call   1070 <blocksCount@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jl     121c <testSparse+0x9c>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
lea    0xddd(%rip),%rdi
mov    $0x5,%esi
mov    $0x63,%edx
call   1050 <changeByte@plt>
lea    0xe1a(%rip),%rdi
lea    0xdc0(%rip),%rsi
lea    0xde1(%rip),%rdx
mov    $0x1,%ecx
xor    %r8d,%r8d
call   1080 <syncAndCheckMd4@plt>
lea    0xe0f(%rip),%rdi
lea    0xdc6(%rip),%rsi
mov    $0x500000,%edx
call   1030 <checkFileSize@plt>
lea    0xdb5(%rip),%rdi
call   1070 <blocksCount@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jl     1296 <testSparse+0x116>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
lea    0xd63(%rip),%rdi
mov    $0x5,%esi
xor    %edx,%edx
call   1050 <changeByte@plt>
lea    0xdd7(%rip),%rdi
lea    0xd49(%rip),%rsi
lea    0xd6a(%rip),%rdx
mov    $0x1,%ecx
xor    %r8d,%r8d
call   1080 <syncAndCheckMd4@plt>
lea    0xdd4(%rip),%rdi
lea    0xd4f(%rip),%rsi
mov    $0x500000,%edx
call   1030 <checkFileSize@plt>
lea    0xd3e(%rip),%rdi
call   1070 <blocksCount@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jl     130d <testSparse+0x18d>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
lea    0xcec(%rip),%rdi
mov    $0x500000,%esi
xor    %edx,%edx
call   10a0 <addBytes@plt>
lea    0xcd9(%rip),%rdi
call   1070 <blocksCount@plt>
mov    %rax,-0x10(%rbp)
lea    0xd94(%rip),%rdi
lea    0xcc2(%rip),%rsi
lea    0xce3(%rip),%rdx
mov    $0x1,%ecx
xor    %r8d,%r8d
call   1080 <syncAndCheckMd4@plt>
lea    0xd87(%rip),%rdi
lea    0xcc8(%rip),%rsi
mov    $0xa00000,%edx
call   1030 <checkFileSize@plt>
lea    0xcb7(%rip),%rdi
call   1070 <blocksCount@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jl     1394 <testSparse+0x214>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
lea    0xc65(%rip),%rdi
mov    $0x700000,%esi
mov    $0x63,%edx
call   1050 <changeByte@plt>
lea    0xd4a(%rip),%rdi
lea    0xc48(%rip),%rsi
lea    0xc69(%rip),%rdx
mov    $0x1,%ecx
xor    %r8d,%r8d
call   1080 <syncAndCheckMd4@plt>
lea    0xd43(%rip),%rdi
lea    0xc4e(%rip),%rsi
mov    $0xa00000,%edx
call   1030 <checkFileSize@plt>
lea    0xc3d(%rip),%rdi
call   1070 <blocksCount@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jl     140e <testSparse+0x28e>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
cmpq   $0x0,-0x8(%rbp)
jle    1425 <testSparse+0x2a5>
lea    0xd17(%rip),%rdi
call   1040 <printf@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<testSparse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
xor    %eax,%eax
call   1090 <cleanup@plt>
lea    0xe67(%rip),%r14
mov    %r14,%rdi
mov    $0x500000,%esi
call   1060 <createZeroFile@plt>
mov    %r14,%rdi
call   1070 <blocksCount@plt>
mov    %rax,%r15
lea    0xe57(%rip),%rdi
lea    0xe69(%rip),%r12
mov    %r14,%rsi
mov    %r12,%rdx
mov    $0x1,%ecx
xor    %r8d,%r8d
call   1080 <syncAndCheckMd4@plt>
lea    0xe5c(%rip),%rdi
mov    %r12,%rsi
mov    $0x500000,%edx
call   1030 <checkFileSize@plt>
mov    %r12,%rdi
call   1070 <blocksCount@plt>
xor    %ebx,%ebx
cmp    %r15,%rax
setge  %bl
mov    %r14,%rdi
mov    $0x5,%esi
mov    $0x63,%edx
call   1050 <changeByte@plt>
lea    0xe44(%rip),%rdi
mov    %r14,%rsi
mov    %r12,%rdx
mov    $0x1,%ecx
xor    %r8d,%r8d
call   1080 <syncAndCheckMd4@plt>
lea    0xe41(%rip),%rdi
mov    %r12,%rsi
mov    $0x500000,%edx
call   1030 <checkFileSize@plt>
mov    %r12,%rdi
call   1070 <blocksCount@plt>
lea    0x1(%rbx),%rbp
cmp    %r15,%rax
cmovl  %rbx,%rbp
mov    %r14,%rdi
mov    $0x5,%esi
xor    %edx,%edx
call   1050 <changeByte@plt>
lea    0xe28(%rip),%rdi
mov    %r14,%rsi
mov    %r12,%rdx
mov    $0x1,%ecx
xor    %r8d,%r8d
call   1080 <syncAndCheckMd4@plt>
lea    0xe2d(%rip),%rdi
mov    %r12,%rsi
mov    $0x500000,%edx
call   1030 <checkFileSize@plt>
mov    %r12,%rdi
call   1070 <blocksCount@plt>
xor    %r13d,%r13d
cmp    %r15,%rax
setge  %r13b
add    %rbp,%r13
mov    %r14,%rdi
mov    $0x500000,%esi
xor    %edx,%edx
call   10a0 <addBytes@plt>
mov    %r14,%rdi
call   1070 <blocksCount@plt>
mov    %rax,%r15
lea    0xe0f(%rip),%rdi
mov    %r14,%rsi
mov    %r12,%rdx
mov    $0x1,%ecx
xor    %r8d,%r8d
call   1080 <syncAndCheckMd4@plt>
lea    0xe0a(%rip),%rdi
mov    %r12,%rsi
mov    $0xa00000,%edx
call   1030 <checkFileSize@plt>
mov    %r12,%rdi
call   1070 <blocksCount@plt>
xor    %ebx,%ebx
cmp    %r15,%rax
setge  %bl
add    %r13,%rbx
mov    %r14,%rdi
mov    $0x700000,%esi
mov    $0x63,%edx
call   1050 <changeByte@plt>
lea    0xdec(%rip),%rdi
mov    %r14,%rsi
mov    %r12,%rdx
mov    $0x1,%ecx
xor    %r8d,%r8d
call   1080 <syncAndCheckMd4@plt>
lea    0xded(%rip),%rdi
mov    %r12,%rsi
mov    $0xa00000,%edx
call   1030 <checkFileSize@plt>
mov    %r12,%rdi
call   1070 <blocksCount@plt>
xor    %ecx,%ecx
cmp    %r15,%rax
setge  %cl
neg    %rcx
cmp    %rcx,%rbx
jne    135d <testSparse+0x1dd>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xdd3(%rip),%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <puts@plt>

LLVM IR (-O0):
@.str = [15 x i8] c"testSource.bin\00"
@.str.1 = [25 x i8] c"recreated source to zero\00"
@.str.2 = [13 x i8] c"testDest.bin\00"
@.str.3 = [30 x i8] c"recreated source to zero size\00"
@.str.4 = [23 x i8] c"changed byte (SPARSE) \00"
@.str.5 = [29 x i8] c"changed byte (SPARSE) (size)\00"
@.str.6 = [31 x i8] c"changed byte to zero (SPARSE) \00"
@.str.7 = [37 x i8] c"changed byte to zero (SPARSE) (size)\00"
@.str.8 = [21 x i8] c"added 5 md (SPARSE) \00"
@.str.9 = [27 x i8] c"added 5 md (SPARSE) (size)\00"
@.str.10 = [27 x i8] c"changed one byte (SPARSE) \00"
@.str.11 = [33 x i8] c"changed one byte (SPARSE) (size)\00"
@.str.12 = [284 x i8] c"\0A Warning: sparse mode was enabled, but the destination file doesn't seem\0A to occupy less disk space then the original file. For certain file systems it's\0A okay as they don't support sparse files.\0A\0A This warning is safe, sparse files support is NOT required for data integrity.\0A\0A\00"
define void @testSparse() {
%1 = alloca i64
%2 = alloca i64
%3 = alloca i64
%4 = call i32 (...) @cleanup()
store i64 0, i64* %1
%5 = call i32 @createZeroFile(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i32 5242880)
%6 = call i64 @blocksCount(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0))
store i64 %6, i64* %2
%7 = call i32 @syncAndCheckMd4(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 1, i32 0)
%8 = call i32 @checkFileSize(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 5242880)
%9 = call i64 @blocksCount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0))
store i64 %9, i64* %3
%10 = load i64, i64* %3
%11 = load i64, i64* %2
%12 = icmp sge i64 %10, %11
br i1 %12, label %13, label %16
13: ; preds = %0
%14 = load i64, i64* %1
%15 = add nsw i64 %14, 1
store i64 %15, i64* %1
br label %16
16: ; preds = %13, %0
%17 = call i32 @changeByte(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i32 5, i8 signext 99)
%18 = call i32 @syncAndCheckMd4(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 1, i32 0)
%19 = call i32 @checkFileSize(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 5242880)
%20 = call i64 @blocksCount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0))
store i64 %20, i64* %3
%21 = load i64, i64* %3
%22 = load i64, i64* %2
%23 = icmp sge i64 %21, %22
br i1 %23, label %24, label %27
24: ; preds = %16
%25 = load i64, i64* %1
%26 = add nsw i64 %25, 1
store i64 %26, i64* %1
br label %27
27: ; preds = %24, %16
%28 = call i32 @changeByte(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i32 5, i8 signext 0)
%29 = call i32 @syncAndCheckMd4(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 1, i32 0)
%30 = call i32 @checkFileSize(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 5242880)
%31 = call i64 @blocksCount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0))
store i64 %31, i64* %3
%32 = load i64, i64* %3
%33 = load i64, i64* %2
%34 = icmp sge i64 %32, %33
br i1 %34, label %35, label %38
35: ; preds = %27
%36 = load i64, i64* %1
%37 = add nsw i64 %36, 1
store i64 %37, i64* %1
br label %38
38: ; preds = %35, %27
%39 = call i32 @addBytes(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i32 5242880, i32 0)
%40 = call i64 @blocksCount(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0))
store i64 %40, i64* %2
%41 = call i32 @syncAndCheckMd4(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 1, i32 0)
%42 = call i32 @checkFileSize(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 10485760)
%43 = call i64 @blocksCount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0))
store i64 %43, i64* %3
%44 = load i64, i64* %3
%45 = load i64, i64* %2
%46 = icmp sge i64 %44, %45
br i1 %46, label %47, label %50
47: ; preds = %38
%48 = load i64, i64* %1
%49 = add nsw i64 %48, 1
store i64 %49, i64* %1
br label %50
50: ; preds = %47, %38
%51 = call i32 @changeByte(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i32 7340032, i8 signext 99)
%52 = call i32 @syncAndCheckMd4(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 1, i32 0)
%53 = call i32 @checkFileSize(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 10485760)
%54 = call i64 @blocksCount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0))
store i64 %54, i64* %3
%55 = load i64, i64* %3
%56 = load i64, i64* %2
%57 = icmp sge i64 %55, %56
br i1 %57, label %58, label %61
58: ; preds = %50
%59 = load i64, i64* %1
%60 = add nsw i64 %59, 1
store i64 %60, i64* %1
br label %61
61: ; preds = %58, %50
%62 = load i64, i64* %1
%63 = icmp sgt i64 %62, 0
br i1 %63, label %64, label %66
64: ; preds = %61
%65 = call i32 @printf(i8* getelementptr inbounds ([284 x i8], [284 x i8]* @.str.12, i64 0, i64 0))
br label %66
66: ; preds = %64, %61
ret void
}

LLVM IR (-O2):
@.str = [15 x i8] c"testSource.bin\00"
@.str.1 = [25 x i8] c"recreated source to zero\00"
@.str.2 = [13 x i8] c"testDest.bin\00"
@.str.3 = [30 x i8] c"recreated source to zero size\00"
@.str.4 = [23 x i8] c"changed byte (SPARSE) \00"
@.str.5 = [29 x i8] c"changed byte (SPARSE) (size)\00"
@.str.6 = [31 x i8] c"changed byte to zero (SPARSE) \00"
@.str.7 = [37 x i8] c"changed byte to zero (SPARSE) (size)\00"
@.str.8 = [21 x i8] c"added 5 md (SPARSE) \00"
@.str.9 = [27 x i8] c"added 5 md (SPARSE) (size)\00"
@.str.10 = [27 x i8] c"changed one byte (SPARSE) \00"
@.str.11 = [33 x i8] c"changed one byte (SPARSE) (size)\00"
@str = [283 x i8] c"\0A Warning: sparse mode was enabled, but the destination file doesn't seem\0A to occupy less disk space then the original file. For certain file systems it's\0A okay as they don't support sparse files.\0A\0A This warning is safe, sparse files support is NOT required for data integrity.\0A\00"
define void @testSparse() {
%1 = tail call i32 (...) @cleanup()
%2 = tail call i32 @createZeroFile(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i32 5242880)
%3 = tail call i64 @blocksCount(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0))
%4 = tail call i32 @syncAndCheckMd4(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 1, i32 0)
%5 = tail call i32 @checkFileSize(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 5242880)
%6 = tail call i64 @blocksCount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0))
%7 = icmp sge i64 %6, %3
%8 = zext i1 %7 to i64
%9 = tail call i32 @changeByte(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i32 5, i8 signext 99)
%10 = tail call i32 @syncAndCheckMd4(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 1, i32 0)
%11 = tail call i32 @checkFileSize(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 5242880)
%12 = tail call i64 @blocksCount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0))
%13 = icmp slt i64 %12, %3
%14 = select i1 %7, i64 2, i64 1
%15 = select i1 %13, i64 %8, i64 %14
%16 = tail call i32 @changeByte(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i32 5, i8 signext 0)
%17 = tail call i32 @syncAndCheckMd4(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 1, i32 0)
%18 = tail call i32 @checkFileSize(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 5242880)
%19 = tail call i64 @blocksCount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0))
%20 = icmp sge i64 %19, %3
%21 = zext i1 %20 to i64
%22 = add nuw nsw i64 %15, %21
%23 = tail call i32 @addBytes(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i32 5242880, i32 0)
%24 = tail call i64 @blocksCount(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0))
%25 = tail call i32 @syncAndCheckMd4(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 1, i32 0)
%26 = tail call i32 @checkFileSize(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 10485760)
%27 = tail call i64 @blocksCount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0))
%28 = icmp sge i64 %27, %24
%29 = zext i1 %28 to i64
%30 = add nuw nsw i64 %22, %29
%31 = tail call i32 @changeByte(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i32 7340032, i8 signext 99)
%32 = tail call i32 @syncAndCheckMd4(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 1, i32 0)
%33 = tail call i32 @checkFileSize(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 10485760)
%34 = tail call i64 @blocksCount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0))
%35 = icmp sge i64 %34, %24
%36 = sext i1 %35 to i64
%37 = icmp eq i64 %30, %36
br i1 %37, label %40, label %38
38: ; preds = %0
%39 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([283 x i8], [283 x i8]* @str, i64 0, i64 0))
br label %40
40: ; preds = %38, %0
ret void
}