#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*/ array5;
typedef int /*<<< orphan*/ array4;
typedef int /*<<< orphan*/ array3;
typedef int /*<<< orphan*/ array2;
typedef int /*<<< orphan*/ array1;
typedef int /*<<< orphan*/ array0;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
scalar_t__ memcmp(int *, int *, int);
int /*<<< orphan*/ move_all_zeros_to_end_without_changing_order(int *, int);
int main() {
  int array0[] = {0, 9, 1, 2, 3, 0};
  int len0 = sizeof(array0) / sizeof(int);
  int exp_array0[] = {9, 1, 2, 3, 0, 0};
  move_all_zeros_to_end_without_changing_order(array0, len0);
  assert(0 == memcmp(array0, exp_array0, sizeof(array0)));
  int array1[] = {8, 9, 1, 2, 3, 9};
  int len1 = sizeof(array1) / sizeof(int);
  int exp_array1[] = {8, 9, 1, 2, 3, 9};
  move_all_zeros_to_end_without_changing_order(array1, len1);
  assert(0 == memcmp(array1, exp_array1, sizeof(array1)));
  int array2[] = {0, 0, 0, 0, 0, 0};
  int len2 = sizeof(array2) / sizeof(int);
  int exp_array2[] = {0, 0, 0, 0, 0, 0};
  move_all_zeros_to_end_without_changing_order(array2, len2);
  assert(0 == memcmp(array2, exp_array2, sizeof(array2)));
  int array3[] = {8, 9, 1, 2, 3, 0, 1, 2, 3};
  int len3 = sizeof(array3) / sizeof(int);
  int exp_array3[] = {8, 9, 1, 2, 3, 1, 2, 3, 0};
  move_all_zeros_to_end_without_changing_order(array3, len3);
  assert(0 == memcmp(array3, exp_array3, sizeof(array3)));
  int array4[] = {8, 9, 1, 2, 3, 1, 2, 3, 0};
  int len4 = sizeof(array4) / sizeof(int);
  int exp_array4[] = {8, 9, 1, 2, 3, 1, 2, 3, 0};
  move_all_zeros_to_end_without_changing_order(array4, len4);
  assert(0 == memcmp(array4, exp_array4, sizeof(array4)));
  int array5[] = {0, 0, 8, 9, 1, 2, 3, 1, 2, 3};
  int len5 = sizeof(array5) / sizeof(int);
  int exp_array5[] = {8, 9, 1, 2, 3, 1, 2, 3, 0, 0};
  move_all_zeros_to_end_without_changing_order(array5, len5);
  assert(0 == memcmp(array5, exp_array5, sizeof(array5)));
  return (0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1e0,%rsp
movl   $0x0,-0x4(%rbp)
mov    0xe97(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    0xe94(%rip),%rax
mov    %rax,-0x18(%rbp)
mov    0xe91(%rip),%rax
mov    %rax,-0x10(%rbp)
movl   $0x6,-0x24(%rbp)
mov    0xe8f(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xe8c(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0xe89(%rip),%rax
mov    %rax,-0x30(%rbp)
lea    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
call   1070 <move_all_zeros_to_end_without_changing_order@plt>
lea    -0x20(%rbp),%rdi
lea    -0x40(%rbp),%rsi
mov    $0x18,%edx
call   1040 <memcmp@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    0xe5b(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    0xe58(%rip),%rax
mov    %rax,-0x58(%rbp)
mov    0xe55(%rip),%rax
mov    %rax,-0x50(%rbp)
movl   $0x6,-0x64(%rbp)
mov    0xe53(%rip),%rax
mov    %rax,-0x80(%rbp)
mov    0xe50(%rip),%rax
mov    %rax,-0x78(%rbp)
mov    0xe4d(%rip),%rax
mov    %rax,-0x70(%rbp)
lea    -0x60(%rbp),%rdi
mov    -0x64(%rbp),%esi
call   1070 <move_all_zeros_to_end_without_changing_order@plt>
lea    -0x60(%rbp),%rdi
lea    -0x80(%rbp),%rsi
mov    $0x18,%edx
call   1040 <memcmp@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0xa0(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
movl   $0x6,-0xa4(%rbp)
lea    -0xc0(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0xa0(%rbp),%rdi
mov    -0xa4(%rbp),%esi
call   1070 <move_all_zeros_to_end_without_changing_order@plt>
lea    -0xa0(%rbp),%rdi
lea    -0xc0(%rbp),%rsi
mov    $0x18,%edx
call   1040 <memcmp@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0xf0(%rbp),%rdi
lea    0xda9(%rip),%rsi
mov    $0x24,%edx
call   1060 <memcpy@plt>
movl   $0x9,-0xf4(%rbp)
lea    -0x120(%rbp),%rdi
lea    0xe17(%rip),%rsi
mov    $0x24,%edx
call   1060 <memcpy@plt>
lea    -0xf0(%rbp),%rdi
mov    -0xf4(%rbp),%esi
call   1070 <move_all_zeros_to_end_without_changing_order@plt>
lea    -0xf0(%rbp),%rdi
lea    -0x120(%rbp),%rsi
mov    $0x24,%edx
call   1040 <memcmp@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x150(%rbp),%rdi
lea    0xdc0(%rip),%rsi
mov    $0x24,%edx
call   1060 <memcpy@plt>
movl   $0x9,-0x154(%rbp)
lea    -0x180(%rbp),%rdi
lea    0xd9e(%rip),%rsi
mov    $0x24,%edx
call   1060 <memcpy@plt>
lea    -0x150(%rbp),%rdi
mov    -0x154(%rbp),%esi
call   1070 <move_all_zeros_to_end_without_changing_order@plt>
lea    -0x150(%rbp),%rdi
lea    -0x180(%rbp),%rsi
mov    $0x24,%edx
call   1040 <memcmp@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
lea    -0x1b0(%rbp),%rdi
lea    0xce7(%rip),%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
movl   $0xa,-0x1b4(%rbp)
lea    -0x1e0(%rbp),%rdi
lea    0xcf5(%rip),%rsi
mov    $0x28,%edx
call   1060 <memcpy@plt>
lea    -0x1b0(%rbp),%rdi
mov    -0x1b4(%rbp),%esi
call   1070 <move_all_zeros_to_end_without_changing_order@plt>
lea    -0x1b0(%rbp),%rdi
lea    -0x1e0(%rbp),%rsi
mov    $0x28,%edx
call   1040 <memcmp@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
xor    %eax,%eax
add    $0x1e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %rbx
sub    $0x1d8,%rsp
mov    0xed0(%rip),%rax
mov    %rax,0xb0(%rsp)
movaps 0xeb1(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
mov    0xed2(%rip),%rax
mov    %rax,0x90(%rsp)
movaps 0xeb3(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
lea    0xa0(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x6,%esi
call   1050 <move_all_zeros_to_end_without_changing_order@plt>
lea    0x80(%rsp),%rsi
mov    %rbx,%rdi
mov    $0x18,%edx
call   1030 <memcmp@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1040 <assert@plt>
mov    0xe9c(%rip),%rax
mov    %rax,0x70(%rsp)
movaps 0xe80(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
mov    %rax,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
lea    0x60(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x6,%esi
call   1050 <move_all_zeros_to_end_without_changing_order@plt>
lea    0x40(%rsp),%rsi
mov    %rbx,%rdi
mov    $0x18,%edx
call   1030 <memcmp@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1040 <assert@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
movq   $0x0,0x30(%rsp)
movaps %xmm0,(%rsp)
movq   $0x0,0x10(%rsp)
lea    0x20(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x6,%esi
call   1050 <move_all_zeros_to_end_without_changing_order@plt>
mov    %rsp,%rsi
mov    %rbx,%rdi
mov    $0x18,%edx
call   1030 <memcmp@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1040 <assert@plt>
mov    0xe2b(%rip),%eax
mov    %eax,0x170(%rsp)
movaps 0xe0d(%rip),%xmm0
movaps %xmm0,0x160(%rsp)
movaps 0xdee(%rip),%xmm0
movaps %xmm0,0x150(%rsp)
mov    0xe90(%rip),%ebp
mov    %ebp,0x140(%rsp)
movaps 0xe72(%rip),%xmm0
movaps %xmm0,0x130(%rsp)
movaps 0xe53(%rip),%xmm0
movaps %xmm0,0x120(%rsp)
lea    0x150(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x9,%esi
call   1050 <move_all_zeros_to_end_without_changing_order@plt>
lea    0x120(%rsp),%rsi
mov    %rbx,%rdi
mov    $0x24,%edx
call   1030 <memcmp@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1040 <assert@plt>
mov    %ebp,0x110(%rsp)
movaps 0xe15(%rip),%xmm0
movaps %xmm0,0x100(%rsp)
movaps 0xdf6(%rip),%xmm1
movaps %xmm1,0xf0(%rsp)
mov    %ebp,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm1,0xc0(%rsp)
lea    0xf0(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x9,%esi
call   1050 <move_all_zeros_to_end_without_changing_order@plt>
lea    0xc0(%rsp),%rsi
mov    %rbx,%rdi
mov    $0x24,%edx
call   1030 <memcmp@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1040 <assert@plt>
mov    0xd58(%rip),%rax
mov    %rax,0x1d0(%rsp)
movaps 0xd39(%rip),%xmm0
movaps %xmm0,0x1c0(%rsp)
movaps 0xd1a(%rip),%xmm0
movaps %xmm0,0x1b0(%rsp)
mov    0xd5b(%rip),%rax
mov    %rax,0x1a0(%rsp)
movaps 0xd3c(%rip),%xmm0
movaps %xmm0,0x190(%rsp)
movaps 0xd1d(%rip),%xmm0
movaps %xmm0,0x180(%rsp)
lea    0x1b0(%rsp),%rbx
mov    %rbx,%rdi
mov    $0xa,%esi
call   1050 <move_all_zeros_to_end_without_changing_order@plt>
lea    0x180(%rsp),%rsi
mov    %rbx,%rdi
mov    $0x28,%edx
call   1030 <memcmp@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1040 <assert@plt>
xor    %eax,%eax
add    $0x1d8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
@__const.main.array0 = [6 x i32] [i32 0, i32 9, i32 1, i32 2, i32 3, i32 0]
@__const.main.exp_array0 = [6 x i32] [i32 9, i32 1, i32 2, i32 3, i32 0, i32 0]
@__const.main.array1 = [6 x i32] [i32 8, i32 9, i32 1, i32 2, i32 3, i32 9]
@__const.main.exp_array1 = [6 x i32] [i32 8, i32 9, i32 1, i32 2, i32 3, i32 9]
@__const.main.array3 = [9 x i32] [i32 8, i32 9, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3]
@__const.main.exp_array3 = [9 x i32] [i32 8, i32 9, i32 1, i32 2, i32 3, i32 1, i32 2, i32 3, i32 0]
@__const.main.array4 = [9 x i32] [i32 8, i32 9, i32 1, i32 2, i32 3, i32 1, i32 2, i32 3, i32 0]
@__const.main.exp_array4 = [9 x i32] [i32 8, i32 9, i32 1, i32 2, i32 3, i32 1, i32 2, i32 3, i32 0]
@__const.main.array5 = [10 x i32] [i32 0, i32 0, i32 8, i32 9, i32 1, i32 2, i32 3, i32 1, i32 2, i32 3]
@__const.main.exp_array5 = [10 x i32] [i32 8, i32 9, i32 1, i32 2, i32 3, i32 1, i32 2, i32 3, i32 0, i32 0]
define i32 @main() {
%1 = alloca i32
%2 = alloca [6 x i32]
%3 = alloca i32
%4 = alloca [6 x i32]
%5 = alloca [6 x i32]
%6 = alloca i32
%7 = alloca [6 x i32]
%8 = alloca [6 x i32]
%9 = alloca i32
%10 = alloca [6 x i32]
%11 = alloca [9 x i32]
%12 = alloca i32
%13 = alloca [9 x i32]
%14 = alloca [9 x i32]
%15 = alloca i32
%16 = alloca [9 x i32]
%17 = alloca [10 x i32]
%18 = alloca i32
%19 = alloca [10 x i32]
store i32 0, i32* %1
%20 = bitcast [6 x i32]* %2 to i8*
store i32 6, i32* %3
%21 = bitcast [6 x i32]* %4 to i8*
%22 = getelementptr inbounds [6 x i32], [6 x i32]* %2, i64 0, i64 0
%23 = load i32, i32* %3
%24 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %22, i32 %23)
%25 = getelementptr inbounds [6 x i32], [6 x i32]* %2, i64 0, i64 0
%26 = getelementptr inbounds [6 x i32], [6 x i32]* %4, i64 0, i64 0
%27 = call i64 @memcmp(i32* %25, i32* %26, i32 24)
%28 = icmp eq i64 0, %27
%29 = zext i1 %28 to i32
%30 = call i32 @assert(i32 %29)
%31 = bitcast [6 x i32]* %5 to i8*
store i32 6, i32* %6
%32 = bitcast [6 x i32]* %7 to i8*
%33 = getelementptr inbounds [6 x i32], [6 x i32]* %5, i64 0, i64 0
%34 = load i32, i32* %6
%35 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %33, i32 %34)
%36 = getelementptr inbounds [6 x i32], [6 x i32]* %5, i64 0, i64 0
%37 = getelementptr inbounds [6 x i32], [6 x i32]* %7, i64 0, i64 0
%38 = call i64 @memcmp(i32* %36, i32* %37, i32 24)
%39 = icmp eq i64 0, %38
%40 = zext i1 %39 to i32
%41 = call i32 @assert(i32 %40)
%42 = bitcast [6 x i32]* %8 to i8*
store i32 6, i32* %9
%43 = bitcast [6 x i32]* %10 to i8*
%44 = getelementptr inbounds [6 x i32], [6 x i32]* %8, i64 0, i64 0
%45 = load i32, i32* %9
%46 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %44, i32 %45)
%47 = getelementptr inbounds [6 x i32], [6 x i32]* %8, i64 0, i64 0
%48 = getelementptr inbounds [6 x i32], [6 x i32]* %10, i64 0, i64 0
%49 = call i64 @memcmp(i32* %47, i32* %48, i32 24)
%50 = icmp eq i64 0, %49
%51 = zext i1 %50 to i32
%52 = call i32 @assert(i32 %51)
%53 = bitcast [9 x i32]* %11 to i8*
store i32 9, i32* %12
%54 = bitcast [9 x i32]* %13 to i8*
%55 = getelementptr inbounds [9 x i32], [9 x i32]* %11, i64 0, i64 0
%56 = load i32, i32* %12
%57 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %55, i32 %56)
%58 = getelementptr inbounds [9 x i32], [9 x i32]* %11, i64 0, i64 0
%59 = getelementptr inbounds [9 x i32], [9 x i32]* %13, i64 0, i64 0
%60 = call i64 @memcmp(i32* %58, i32* %59, i32 36)
%61 = icmp eq i64 0, %60
%62 = zext i1 %61 to i32
%63 = call i32 @assert(i32 %62)
%64 = bitcast [9 x i32]* %14 to i8*
store i32 9, i32* %15
%65 = bitcast [9 x i32]* %16 to i8*
%66 = getelementptr inbounds [9 x i32], [9 x i32]* %14, i64 0, i64 0
%67 = load i32, i32* %15
%68 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %66, i32 %67)
%69 = getelementptr inbounds [9 x i32], [9 x i32]* %14, i64 0, i64 0
%70 = getelementptr inbounds [9 x i32], [9 x i32]* %16, i64 0, i64 0
%71 = call i64 @memcmp(i32* %69, i32* %70, i32 36)
%72 = icmp eq i64 0, %71
%73 = zext i1 %72 to i32
%74 = call i32 @assert(i32 %73)
%75 = bitcast [10 x i32]* %17 to i8*
store i32 10, i32* %18
%76 = bitcast [10 x i32]* %19 to i8*
%77 = getelementptr inbounds [10 x i32], [10 x i32]* %17, i64 0, i64 0
%78 = load i32, i32* %18
%79 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %77, i32 %78)
%80 = getelementptr inbounds [10 x i32], [10 x i32]* %17, i64 0, i64 0
%81 = getelementptr inbounds [10 x i32], [10 x i32]* %19, i64 0, i64 0
%82 = call i64 @memcmp(i32* %80, i32* %81, i32 40)
%83 = icmp eq i64 0, %82
%84 = zext i1 %83 to i32
%85 = call i32 @assert(i32 %84)
ret i32 0
}

LLVM IR (-O2):
@__const.main.array0 = [6 x i32] [i32 0, i32 9, i32 1, i32 2, i32 3, i32 0]
@__const.main.exp_array0 = [6 x i32] [i32 9, i32 1, i32 2, i32 3, i32 0, i32 0]
@__const.main.exp_array1 = [6 x i32] [i32 8, i32 9, i32 1, i32 2, i32 3, i32 9]
@__const.main.array3 = [9 x i32] [i32 8, i32 9, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3]
@__const.main.exp_array4 = [9 x i32] [i32 8, i32 9, i32 1, i32 2, i32 3, i32 1, i32 2, i32 3, i32 0]
@__const.main.array5 = [10 x i32] [i32 0, i32 0, i32 8, i32 9, i32 1, i32 2, i32 3, i32 1, i32 2, i32 3]
@__const.main.exp_array5 = [10 x i32] [i32 8, i32 9, i32 1, i32 2, i32 3, i32 1, i32 2, i32 3, i32 0, i32 0]
define i32 @main() {
%1 = alloca [6 x i32]
%2 = alloca [6 x i32]
%3 = alloca [6 x i32]
%4 = alloca [6 x i32]
%5 = alloca [6 x i32]
%6 = alloca [6 x i32]
%7 = alloca [9 x i32]
%8 = alloca [9 x i32]
%9 = alloca [9 x i32]
%10 = alloca [9 x i32]
%11 = alloca [10 x i32]
%12 = alloca [10 x i32]
%13 = bitcast [6 x i32]* %1 to i8*
%14 = bitcast [6 x i32]* %2 to i8*
%15 = getelementptr inbounds [6 x i32], [6 x i32]* %1, i64 0, i64 0
%16 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %15, i32 6)
%17 = getelementptr inbounds [6 x i32], [6 x i32]* %2, i64 0, i64 0
%18 = call i64 @memcmp(i32* %15, i32* %17, i32 24)
%19 = icmp eq i64 %18, 0
%20 = zext i1 %19 to i32
%21 = call i32 @assert(i32 %20)
%22 = bitcast [6 x i32]* %3 to i8*
%23 = bitcast [6 x i32]* %4 to i8*
%24 = getelementptr inbounds [6 x i32], [6 x i32]* %3, i64 0, i64 0
%25 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %24, i32 6)
%26 = getelementptr inbounds [6 x i32], [6 x i32]* %4, i64 0, i64 0
%27 = call i64 @memcmp(i32* %24, i32* %26, i32 24)
%28 = icmp eq i64 %27, 0
%29 = zext i1 %28 to i32
%30 = call i32 @assert(i32 %29)
%31 = bitcast [6 x i32]* %5 to i8*
%32 = bitcast [6 x i32]* %6 to i8*
%33 = getelementptr inbounds [6 x i32], [6 x i32]* %5, i64 0, i64 0
%34 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %33, i32 6)
%35 = getelementptr inbounds [6 x i32], [6 x i32]* %6, i64 0, i64 0
%36 = call i64 @memcmp(i32* %33, i32* %35, i32 24)
%37 = icmp eq i64 %36, 0
%38 = zext i1 %37 to i32
%39 = call i32 @assert(i32 %38)
%40 = bitcast [9 x i32]* %7 to i8*
%41 = bitcast [9 x i32]* %8 to i8*
%42 = getelementptr inbounds [9 x i32], [9 x i32]* %7, i64 0, i64 0
%43 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %42, i32 9)
%44 = getelementptr inbounds [9 x i32], [9 x i32]* %8, i64 0, i64 0
%45 = call i64 @memcmp(i32* %42, i32* %44, i32 36)
%46 = icmp eq i64 %45, 0
%47 = zext i1 %46 to i32
%48 = call i32 @assert(i32 %47)
%49 = bitcast [9 x i32]* %9 to i8*
%50 = bitcast [9 x i32]* %10 to i8*
%51 = getelementptr inbounds [9 x i32], [9 x i32]* %9, i64 0, i64 0
%52 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %51, i32 9)
%53 = getelementptr inbounds [9 x i32], [9 x i32]* %10, i64 0, i64 0
%54 = call i64 @memcmp(i32* %51, i32* %53, i32 36)
%55 = icmp eq i64 %54, 0
%56 = zext i1 %55 to i32
%57 = call i32 @assert(i32 %56)
%58 = bitcast [10 x i32]* %11 to i8*
%59 = bitcast [10 x i32]* %12 to i8*
%60 = getelementptr inbounds [10 x i32], [10 x i32]* %11, i64 0, i64 0
%61 = call i32 @move_all_zeros_to_end_without_changing_order(i32* %60, i32 10)
%62 = getelementptr inbounds [10 x i32], [10 x i32]* %12, i64 0, i64 0
%63 = call i64 @memcmp(i32* %60, i32* %62, i32 40)
%64 = icmp eq i64 %63, 0
%65 = zext i1 %64 to i32
%66 = call i32 @assert(i32 %65)
ret i32 0
}