#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*/ assert(int);
int /*<<< orphan*/ printf(char *);
int rand_num(unsigned int *);
void test_rand_num() {
  unsigned int random_seed = 562482;
  int i, j, rand_value[10];
  printf("test_rand_num...");
  for (i = 0; i < 10; i++) {
    rand_value[i] = rand_num(&random_seed);
  }
  for (i = 0; i < 9; i++) {
    for (j = i + 1; j < 10; j++) {
      assert(rand_value[i] != rand_value[j]);
    }
  }
  printf("Ok\n");
}


x86 assembly (clang, -O0):
<test_rand_num>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x89532,-0x4(%rbp)
lea    0xeba(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0xa,-0x8(%rbp)
jge    117d <test_rand_num+0x4d>
lea    -0x4(%rbp),%rdi
call   1050 <rand_num@plt>
mov    %eax,%ecx
movslq -0x8(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1152 <test_rand_num+0x22>
movl   $0x0,-0x8(%rbp)
cmpl   $0x9,-0x8(%rbp)
jge    11df <test_rand_num+0xaf>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0xa,-0xc(%rbp)
jge    11cc <test_rand_num+0x9c>
movslq -0x8(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
movslq -0xc(%rbp),%rcx
cmp    -0x40(%rbp,%rcx,4),%eax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1197 <test_rand_num+0x67>
jmp    11d1 <test_rand_num+0xa1>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1184 <test_rand_num+0x54>
lea    0xe2b(%rip),%rdi
call   1030 <printf@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_rand_num>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x30,%rsp
movl   $0x89532,0x2c(%rsp)
lea    0xea5(%rip),%rdi
call   1040 <printf@plt>
lea    0x2c(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <rand_num@plt>
mov    %eax,(%rsp)
mov    %rbx,%rdi
call   1060 <rand_num@plt>
mov    %eax,0x4(%rsp)
mov    %rbx,%rdi
call   1060 <rand_num@plt>
mov    %eax,0x8(%rsp)
mov    %rbx,%rdi
call   1060 <rand_num@plt>
mov    %eax,0xc(%rsp)
mov    %rbx,%rdi
call   1060 <rand_num@plt>
mov    %eax,0x10(%rsp)
mov    %rbx,%rdi
call   1060 <rand_num@plt>
mov    %eax,0x14(%rsp)
mov    %rbx,%rdi
call   1060 <rand_num@plt>
mov    %eax,0x18(%rsp)
mov    %rbx,%rdi
call   1060 <rand_num@plt>
mov    %eax,0x1c(%rsp)
mov    %rbx,%rdi
call   1060 <rand_num@plt>
mov    %eax,0x20(%rsp)
mov    %rbx,%rdi
call   1060 <rand_num@plt>
mov    %eax,0x24(%rsp)
mov    (%rsp),%ebx
xor    %edi,%edi
cmp    0x4(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x8(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0xc(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x10(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x14(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x18(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x1c(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x20(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x24(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
mov    0x4(%rsp),%ebx
xor    %edi,%edi
cmp    0x8(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0xc(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x10(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x14(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x18(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x1c(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x20(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x24(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
mov    0x8(%rsp),%ebx
xor    %edi,%edi
cmp    0xc(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x10(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x14(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x18(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x1c(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x20(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x24(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
mov    0xc(%rsp),%ebx
xor    %edi,%edi
cmp    0x10(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x14(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x18(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x1c(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x20(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x24(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
mov    0x10(%rsp),%ebx
xor    %edi,%edi
cmp    0x14(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
mov    0x18(%rsp),%r14d
xor    %edi,%edi
cmp    %r14d,%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x1c(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    0x20(%rsp),%ebx
setne  %dil
call   1050 <assert@plt>
mov    0x24(%rsp),%r15d
xor    %edi,%edi
cmp    %r15d,%ebx
setne  %dil
call   1050 <assert@plt>
mov    0x14(%rsp),%ebx
xor    %edi,%edi
cmp    %r14d,%ebx
setne  %dil
call   1050 <assert@plt>
mov    0x1c(%rsp),%r12d
xor    %edi,%edi
cmp    %r12d,%ebx
setne  %dil
call   1050 <assert@plt>
mov    0x20(%rsp),%ebp
xor    %edi,%edi
cmp    %ebp,%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    %r15d,%ebx
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    %r12d,%r14d
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    %ebp,%r14d
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    %r15d,%r14d
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    %ebp,%r12d
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    %r15d,%r12d
setne  %dil
call   1050 <assert@plt>
xor    %edi,%edi
cmp    %r15d,%ebp
setne  %dil
call   1050 <assert@plt>
lea    0xb6e(%rip),%rdi
call   1030 <puts@plt>
add    $0x30,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [17 x i8] c"test_rand_num...\00"
@.str.1 = [4 x i8] c"Ok\0A\00"
define void @test_rand_num() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca [10 x i32]
store i32 562482, i32* %1
%5 = call i32 @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %2
br label %6
6: ; preds = %14, %0
%7 = load i32, i32* %2
%8 = icmp slt i32 %7, 10
br i1 %8, label %9, label %17
9: ; preds = %6
%10 = call i32 @rand_num(i32* %1)
%11 = load i32, i32* %2
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %12
store i32 %10, i32* %13
br label %14
14: ; preds = %9
%15 = load i32, i32* %2
%16 = add nsw i32 %15, 1
store i32 %16, i32* %2
br label %6
17: ; preds = %6
store i32 0, i32* %2
br label %18
18: ; preds = %43, %17
%19 = load i32, i32* %2
%20 = icmp slt i32 %19, 9
br i1 %20, label %21, label %46
21: ; preds = %18
%22 = load i32, i32* %2
%23 = add nsw i32 %22, 1
store i32 %23, i32* %3
br label %24
24: ; preds = %39, %21
%25 = load i32, i32* %3
%26 = icmp slt i32 %25, 10
br i1 %26, label %27, label %42
27: ; preds = %24
%28 = load i32, i32* %2
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %29
%31 = load i32, i32* %30
%32 = load i32, i32* %3
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %33
%35 = load i32, i32* %34
%36 = icmp ne i32 %31, %35
%37 = zext i1 %36 to i32
%38 = call i32 @assert(i32 %37)
br label %39
39: ; preds = %27
%40 = load i32, i32* %3
%41 = add nsw i32 %40, 1
store i32 %41, i32* %3
br label %24
42: ; preds = %24
br label %43
43: ; preds = %42
%44 = load i32, i32* %2
%45 = add nsw i32 %44, 1
store i32 %45, i32* %2
br label %18
46: ; preds = %18
%47 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [17 x i8] c"test_rand_num...\00"
@str = [3 x i8] c"Ok\00"
define void @test_rand_num() {
%1 = alloca i32
%2 = alloca [10 x i32]
%3 = bitcast i32* %1 to i8*
store i32 562482, i32* %1
%4 = bitcast [10 x i32]* %2 to i8*
%5 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0))
%6 = call i32 @rand_num(i32* %1)
%7 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 0
store i32 %6, i32* %7
%8 = call i32 @rand_num(i32* %1)
%9 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 1
store i32 %8, i32* %9
%10 = call i32 @rand_num(i32* %1)
%11 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 2
store i32 %10, i32* %11
%12 = call i32 @rand_num(i32* %1)
%13 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 3
store i32 %12, i32* %13
%14 = call i32 @rand_num(i32* %1)
%15 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 4
store i32 %14, i32* %15
%16 = call i32 @rand_num(i32* %1)
%17 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 5
store i32 %16, i32* %17
%18 = call i32 @rand_num(i32* %1)
%19 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 6
store i32 %18, i32* %19
%20 = call i32 @rand_num(i32* %1)
%21 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 7
store i32 %20, i32* %21
%22 = call i32 @rand_num(i32* %1)
%23 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 8
store i32 %22, i32* %23
%24 = call i32 @rand_num(i32* %1)
%25 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 9
store i32 %24, i32* %25
%26 = load i32, i32* %7
%27 = load i32, i32* %9
%28 = icmp ne i32 %26, %27
%29 = zext i1 %28 to i32
%30 = call i32 @assert(i32 %29)
%31 = load i32, i32* %11
%32 = icmp ne i32 %26, %31
%33 = zext i1 %32 to i32
%34 = call i32 @assert(i32 %33)
%35 = load i32, i32* %13
%36 = icmp ne i32 %26, %35
%37 = zext i1 %36 to i32
%38 = call i32 @assert(i32 %37)
%39 = load i32, i32* %15
%40 = icmp ne i32 %26, %39
%41 = zext i1 %40 to i32
%42 = call i32 @assert(i32 %41)
%43 = load i32, i32* %17
%44 = icmp ne i32 %26, %43
%45 = zext i1 %44 to i32
%46 = call i32 @assert(i32 %45)
%47 = load i32, i32* %19
%48 = icmp ne i32 %26, %47
%49 = zext i1 %48 to i32
%50 = call i32 @assert(i32 %49)
%51 = load i32, i32* %21
%52 = icmp ne i32 %26, %51
%53 = zext i1 %52 to i32
%54 = call i32 @assert(i32 %53)
%55 = load i32, i32* %23
%56 = icmp ne i32 %26, %55
%57 = zext i1 %56 to i32
%58 = call i32 @assert(i32 %57)
%59 = load i32, i32* %25
%60 = icmp ne i32 %26, %59
%61 = zext i1 %60 to i32
%62 = call i32 @assert(i32 %61)
%63 = load i32, i32* %9
%64 = load i32, i32* %11
%65 = icmp ne i32 %63, %64
%66 = zext i1 %65 to i32
%67 = call i32 @assert(i32 %66)
%68 = load i32, i32* %13
%69 = icmp ne i32 %63, %68
%70 = zext i1 %69 to i32
%71 = call i32 @assert(i32 %70)
%72 = load i32, i32* %15
%73 = icmp ne i32 %63, %72
%74 = zext i1 %73 to i32
%75 = call i32 @assert(i32 %74)
%76 = load i32, i32* %17
%77 = icmp ne i32 %63, %76
%78 = zext i1 %77 to i32
%79 = call i32 @assert(i32 %78)
%80 = load i32, i32* %19
%81 = icmp ne i32 %63, %80
%82 = zext i1 %81 to i32
%83 = call i32 @assert(i32 %82)
%84 = load i32, i32* %21
%85 = icmp ne i32 %63, %84
%86 = zext i1 %85 to i32
%87 = call i32 @assert(i32 %86)
%88 = load i32, i32* %23
%89 = icmp ne i32 %63, %88
%90 = zext i1 %89 to i32
%91 = call i32 @assert(i32 %90)
%92 = load i32, i32* %25
%93 = icmp ne i32 %63, %92
%94 = zext i1 %93 to i32
%95 = call i32 @assert(i32 %94)
%96 = load i32, i32* %11
%97 = load i32, i32* %13
%98 = icmp ne i32 %96, %97
%99 = zext i1 %98 to i32
%100 = call i32 @assert(i32 %99)
%101 = load i32, i32* %15
%102 = icmp ne i32 %96, %101
%103 = zext i1 %102 to i32
%104 = call i32 @assert(i32 %103)
%105 = load i32, i32* %17
%106 = icmp ne i32 %96, %105
%107 = zext i1 %106 to i32
%108 = call i32 @assert(i32 %107)
%109 = load i32, i32* %19
%110 = icmp ne i32 %96, %109
%111 = zext i1 %110 to i32
%112 = call i32 @assert(i32 %111)
%113 = load i32, i32* %21
%114 = icmp ne i32 %96, %113
%115 = zext i1 %114 to i32
%116 = call i32 @assert(i32 %115)
%117 = load i32, i32* %23
%118 = icmp ne i32 %96, %117
%119 = zext i1 %118 to i32
%120 = call i32 @assert(i32 %119)
%121 = load i32, i32* %25
%122 = icmp ne i32 %96, %121
%123 = zext i1 %122 to i32
%124 = call i32 @assert(i32 %123)
%125 = load i32, i32* %13
%126 = load i32, i32* %15
%127 = icmp ne i32 %125, %126
%128 = zext i1 %127 to i32
%129 = call i32 @assert(i32 %128)
%130 = load i32, i32* %17
%131 = icmp ne i32 %125, %130
%132 = zext i1 %131 to i32
%133 = call i32 @assert(i32 %132)
%134 = load i32, i32* %19
%135 = icmp ne i32 %125, %134
%136 = zext i1 %135 to i32
%137 = call i32 @assert(i32 %136)
%138 = load i32, i32* %21
%139 = icmp ne i32 %125, %138
%140 = zext i1 %139 to i32
%141 = call i32 @assert(i32 %140)
%142 = load i32, i32* %23
%143 = icmp ne i32 %125, %142
%144 = zext i1 %143 to i32
%145 = call i32 @assert(i32 %144)
%146 = load i32, i32* %25
%147 = icmp ne i32 %125, %146
%148 = zext i1 %147 to i32
%149 = call i32 @assert(i32 %148)
%150 = load i32, i32* %15
%151 = load i32, i32* %17
%152 = icmp ne i32 %150, %151
%153 = zext i1 %152 to i32
%154 = call i32 @assert(i32 %153)
%155 = load i32, i32* %19
%156 = icmp ne i32 %150, %155
%157 = zext i1 %156 to i32
%158 = call i32 @assert(i32 %157)
%159 = load i32, i32* %21
%160 = icmp ne i32 %150, %159
%161 = zext i1 %160 to i32
%162 = call i32 @assert(i32 %161)
%163 = load i32, i32* %23
%164 = icmp ne i32 %150, %163
%165 = zext i1 %164 to i32
%166 = call i32 @assert(i32 %165)
%167 = load i32, i32* %25
%168 = icmp ne i32 %150, %167
%169 = zext i1 %168 to i32
%170 = call i32 @assert(i32 %169)
%171 = load i32, i32* %17
%172 = icmp ne i32 %171, %155
%173 = zext i1 %172 to i32
%174 = call i32 @assert(i32 %173)
%175 = load i32, i32* %21
%176 = icmp ne i32 %171, %175
%177 = zext i1 %176 to i32
%178 = call i32 @assert(i32 %177)
%179 = load i32, i32* %23
%180 = icmp ne i32 %171, %179
%181 = zext i1 %180 to i32
%182 = call i32 @assert(i32 %181)
%183 = icmp ne i32 %171, %167
%184 = zext i1 %183 to i32
%185 = call i32 @assert(i32 %184)
%186 = icmp ne i32 %155, %175
%187 = zext i1 %186 to i32
%188 = call i32 @assert(i32 %187)
%189 = icmp ne i32 %155, %179
%190 = zext i1 %189 to i32
%191 = call i32 @assert(i32 %190)
%192 = icmp ne i32 %155, %167
%193 = zext i1 %192 to i32
%194 = call i32 @assert(i32 %193)
%195 = icmp ne i32 %175, %179
%196 = zext i1 %195 to i32
%197 = call i32 @assert(i32 %196)
%198 = icmp ne i32 %175, %167
%199 = zext i1 %198 to i32
%200 = call i32 @assert(i32 %199)
%201 = icmp ne i32 %179, %167
%202 = zext i1 %201 to i32
%203 = call i32 @assert(i32 %202)
%204 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str, i64 0, i64 0))
ret void
}