/export/starexec/sandbox/solver/bin/starexec_run_c /export/starexec/sandbox/benchmark/theBenchmark.c /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


MAYBE
proof of /export/starexec/sandbox/benchmark/theBenchmark.c
# AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty


Termination of the given C Problem could not be shown:

(0) C Problem
(1) CToLLVMProof [EQUIVALENT, 203 ms]
(2) LLVM problem


----------------------------------------

(0)
Obligation:
c file /export/starexec/sandbox/benchmark/theBenchmark.c
----------------------------------------

(1) CToLLVMProof (EQUIVALENT)
Compiled c-file /export/starexec/sandbox/benchmark/theBenchmark.c to LLVM.
----------------------------------------

(2)
Obligation:
LLVM Problem

Aliases:

Data layout:

"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"

Machine:

"x86_64-pc-linux-gnu"

Type definitions:

union.__CS__u --> BasicStructureType(elementType: [2 x i32])

Global variables:

Name: __CS_round initVal: 0 type: i8 addrSpace: null alignment: 1 threadLocal: false constant: false linkageType: null section: null

Name: __CS_ret initVal: 0 type: i8 addrSpace: null alignment: 1 threadLocal: false constant: false linkageType: null section: null

Name: __CS_ret_PREEMPTED initVal: 1 type: i8 addrSpace: null alignment: 1 threadLocal: false constant: true linkageType: null section: null

Name: __CS_ret_ERROR initVal: 2 type: i8 addrSpace: null alignment: 1 threadLocal: false constant: true linkageType: null section: null

Name: __CS_ret_FINISHED initVal: 4 type: i8 addrSpace: null alignment: 1 threadLocal: false constant: true linkageType: null section: null

Name: __CS_error initVal: 0 type: i8 addrSpace: null alignment: 1 threadLocal: false constant: false linkageType: null section: null

Name: __THREAD_UNUSED initVal: 0 type: i8 addrSpace: null alignment: 1 threadLocal: false constant: true linkageType: null section: null

Name: __THREAD_RUNNING initVal: 1 type: i8 addrSpace: null alignment: 1 threadLocal: false constant: true linkageType: null section: null

Name: __THREAD_FINISHED initVal: 2 type: i8 addrSpace: null alignment: 1 threadLocal: false constant: true linkageType: null section: null

Name: __CS_thread_index initVal: 0 type: i8 addrSpace: null alignment: 1 threadLocal: false constant: false linkageType: COMMON section: null

Name: __CS_thread_lockedon initVal: ((null,null,null),(null,null,null)) type: [2 x [3 x *i8]] addrSpace: null alignment: 16 threadLocal: false constant: false linkageType: COMMON section: null

Name: __CS_thread_status initVal: ((0,0,0),(0,0,0)) type: [2 x [3 x i8]] addrSpace: null alignment: 1 threadLocal: false constant: false linkageType: COMMON section: null

Name: __CS_thread_allocated initVal: (0,0,0) type: [3 x i8] addrSpace: null alignment: 1 threadLocal: false constant: false linkageType: COMMON section: null

Name: __CS_thread_born_round initVal: (0,0,0) type: [3 x i8] addrSpace: null alignment: 1 threadLocal: false constant: false linkageType: COMMON section: null

Name: __CS_thread initVal: (null,null,null) type: [3 x *BasicFunctionType varArgs: falsereturnType: *i8paramTypes: (*i8)] addrSpace: null alignment: 16 threadLocal: false constant: false linkageType: COMMON section: null

Name: ma initVal: (0,0) type: [2 x i8] addrSpace: null alignment: 1 threadLocal: false constant: false linkageType: COMMON section: null

Name: data1 initVal: (0,0) type: [2 x i32] addrSpace: null alignment: 4 threadLocal: false constant: false linkageType: COMMON section: null

Name: data2 initVal: (0,0) type: [2 x i32] addrSpace: null alignment: 4 threadLocal: false constant: false linkageType: COMMON section: null

Name: mb initVal: (0,0) type: [2 x i8] addrSpace: null alignment: 1 threadLocal: false constant: false linkageType: COMMON section: null

Name: __CS_u initVal: {(0,0)} type: BasicTypeName typeName: union.__CS__uBasicStructureType(elementType: [2 x i32]) addrSpace: null alignment: 4 threadLocal: false constant: false linkageType: COMMON section: null

Function declarations and definitions:

*BasicFunctionTypename: "__VERIFIER_error" returnParam: BasicVoidType parameters: () variableLength: true visibilityType: DEFAULT callingConvention: ccc
*BasicFunctionTypename: "__VERIFIER_assume" returnParam: BasicVoidType parameters: (i32) variableLength: false visibilityType: DEFAULT callingConvention: ccc
*BasicFunctionTypename: "nondet_int" returnParam: i32 parameters: () variableLength: true visibilityType: DEFAULT callingConvention: ccc
*BasicFunctionTypename: "__VERIFIER_assert" linkageType: EXTERNALLY_VISIBLE returnParam: BasicVoidType parameters: (cond i32) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		store %cond, %1
		%2 = load %1
		%3 = icmp ne %2 0
		br %3, %6, %4
	4:
		br %5
	5:
		Unnamed Call-Instruction = call BasicVoidType (...)* @__VERIFIER_error() noreturn
		unreachable
	6:
		ret void

*BasicFunctionTypename: "__CS_cs" linkageType: EXTERNALLY_VISIBLE returnParam: BasicVoidType parameters: () variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%k = alloca i8, align 1
		%1 = load @__CS_round
		%2 = zext i8 %1 to i32
		%3 = load %k
		%4 = zext i8 %3 to i32
		%5 = add %2 %4
		%6 = icmp slt %5 2
		%7 = zext i1 %6 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %7)
		%8 = load %k
		%9 = zext i8 %8 to i32
		%10 = load @__CS_round
		%11 = zext i8 %10 to i32
		%12 = add %11 %9
		%13 = trunc i32 %12 to i8
		store %13, @__CS_round
		%14 = call i32 (...)* @nondet_int()
		%15 = icmp ne %14 0
		br %15, %16, %21
	16:
		%17 = load @__CS_round
		%18 = zext i8 %17 to i32
		%19 = icmp eq %18 1
		br %19, %20, %21
	20:
		br %24
	21:
		%22 = load @__CS_ret
		%23 = zext i8 %22 to i32
		br %24
	24:
		%25 = phi [1, %20], [%23, %21]
		%26 = trunc i32 %25 to i8
		store %26, @__CS_ret
		ret void

*BasicFunctionTypename: "__CS_pthread_mutex_init" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: (mutex *i8, attr *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca *i8, align 8
		%2 = alloca *i8, align 8
		store %mutex, %1
		store %attr, %2
		ret 0

*BasicFunctionTypename: "__CS_pthread_mutex_destroy" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: (lock *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca *i8, align 8
		store %lock, %1
		%2 = load %1
		%3 = load %2
		%4 = zext i8 %3 to i32
		%5 = load @__CS_thread_index
		%6 = zext i8 %5 to i32
		%7 = icmp ne %4 %6
		br %7, %8, %14
	8:
		%9 = load %1
		%10 = load %9
		%11 = zext i8 %10 to i32
		%12 = icmp ne %11 0
		br %12, %13, %14
	13:
		store 1, @__CS_error
		store 2, @__CS_ret
		br %16
	14:
		%15 = load %1
		store 0, %15
		br %16
	16:
		ret 0

*BasicFunctionTypename: "__CS_pthread_mutex_lock" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: (lock *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		%2 = alloca *i8, align 8
		store %lock, %2
		%3 = load %2
		%4 = load %3
		%5 = zext i8 %4 to i32
		%6 = icmp eq %5 0
		br %6, %7, %13
	7:
		%8 = load @__CS_thread_index
		%9 = zext i8 %8 to i32
		%10 = add %9 1
		%11 = trunc i32 %10 to i8
		%12 = load %2
		store %11, %12
		br %14
	13:
		store 1, @__CS_ret
		store 1, %1
		br %15
	14:
		store 0, %1
		br %15
	15:
		%16 = load %1
		ret %16

*BasicFunctionTypename: "__CS_pthread_mutex_unlock" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: (lock *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		%2 = alloca *i8, align 8
		store %lock, %2
		%3 = load %2
		%4 = load %3
		%5 = zext i8 %4 to i32
		%6 = load @__CS_thread_index
		%7 = zext i8 %6 to i32
		%8 = add %7 1
		%9 = icmp ne %5 %8
		br %9, %10, %11
	10:
		store 1, @__CS_error
		store 2, @__CS_ret
		store 1, %1
		br %14
	11:
		%12 = load %2
		store 0, %12
		br %13
	13:
		store 0, %1
		br %14
	14:
		%15 = load %1
		ret %15

*BasicFunctionTypename: "__CS_pthread_cond_init" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: (cond *i8, attr *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca *i8, align 8
		%2 = alloca *i8, align 8
		store %cond, %1
		store %attr, %2
		ret 0

*BasicFunctionTypename: "__CS_pthread_cond_signal" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: (cond *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca *i8, align 8
		%j = alloca i32, align 4
		store %cond, %1
		store 0, %j
		br %2
	2:
		%3 = load %j
		%4 = icmp sle %3 2
		br %4, %5, %26
	5:
		%6 = load %j
		%7 = sext i32 %6 to i64
		%8 = load @__CS_round
		%9 = zext i8 %8 to i64
		%10 = getelementptr @__CS_thread_lockedon, 0, %9
		%11 = getelementptr %10, 0, %7
		%12 = load %11
		%13 = load %1
		%14 = icmp eq %12 %13
		br %14, %15, %22
	15:
		%16 = load %j
		%17 = sext i32 %16 to i64
		%18 = load @__CS_round
		%19 = zext i8 %18 to i64
		%20 = getelementptr @__CS_thread_lockedon, 0, %19
		%21 = getelementptr %20, 0, %17
		store null, %21
		br %22
	22:
		br %23
	23:
		%24 = load %j
		%25 = add %24 1
		store %25, %j
		br %2
	26:
		ret 0

*BasicFunctionTypename: "__CS_pthread_cond_broadcast" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: (cond *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca *i8, align 8
		%j = alloca i32, align 4
		store %cond, %1
		store 0, %j
		br %2
	2:
		%3 = load %j
		%4 = icmp sle %3 2
		br %4, %5, %26
	5:
		%6 = load %j
		%7 = sext i32 %6 to i64
		%8 = load @__CS_round
		%9 = zext i8 %8 to i64
		%10 = getelementptr @__CS_thread_lockedon, 0, %9
		%11 = getelementptr %10, 0, %7
		%12 = load %11
		%13 = load %1
		%14 = icmp eq %12 %13
		br %14, %15, %22
	15:
		%16 = load %j
		%17 = sext i32 %16 to i64
		%18 = load @__CS_round
		%19 = zext i8 %18 to i64
		%20 = getelementptr @__CS_thread_lockedon, 0, %19
		%21 = getelementptr %20, 0, %17
		store null, %21
		br %22
	22:
		br %23
	23:
		%24 = load %j
		%25 = add %24 1
		store %25, %j
		br %2
	26:
		ret 0

*BasicFunctionTypename: "__CS_pthread_cond_wait" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: (cond *i8, lock *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		%2 = alloca *i8, align 8
		%3 = alloca *i8, align 8
		store %cond, %2
		store %lock, %3
		%4 = load %3
		%5 = load %4
		%6 = zext i8 %5 to i32
		%7 = load @__CS_thread_index
		%8 = zext i8 %7 to i32
		%9 = add %8 1
		%10 = icmp ne %6 %9
		br %10, %11, %12
	11:
		store 1, @__CS_error
		store 2, @__CS_ret
		store 1, %1
		br %34
	12:
		%13 = load %3
		store 0, %13
		br %14
	14:
		%15 = load %2
		%16 = load @__CS_thread_index
		%17 = zext i8 %16 to i64
		%18 = load @__CS_round
		%19 = zext i8 %18 to i64
		%20 = getelementptr @__CS_thread_lockedon, 0, %19
		%21 = getelementptr %20, 0, %17
		store %15, %21
		store 1, @__CS_ret
		%22 = load %3
		%23 = load %22
		%24 = zext i8 %23 to i32
		%25 = icmp eq %24 0
		br %25, %26, %32
	26:
		%27 = load @__CS_thread_index
		%28 = zext i8 %27 to i32
		%29 = add %28 1
		%30 = trunc i32 %29 to i8
		%31 = load %3
		store %30, %31
		br %33
	32:
		store 1, @__CS_ret
		store 1, %1
		br %34
	33:
		store 0, %1
		br %34
	34:
		%35 = load %1
		ret %35

*BasicFunctionTypename: "__CS_assert" linkageType: EXTERNALLY_VISIBLE returnParam: BasicVoidType parameters: (expr i32) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		store %expr, %1
		%2 = load %1
		%3 = icmp ne %2 0
		br %3, %5, %4
	4:
		store 1, @__CS_error
		store 2, @__CS_ret
		br %5
	5:
		ret void

*BasicFunctionTypename: "__CS_assume" linkageType: EXTERNALLY_VISIBLE returnParam: BasicVoidType parameters: (expr i32) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		store %expr, %1
		%2 = load %1
		%3 = icmp ne %2 0
		br %3, %5, %4
	4:
		store 1, @__CS_ret
		br %5
	5:
		ret void

*BasicFunctionTypename: "__CS_pthread_join" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: (thread i8 zeroext, value_ptr **i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		%2 = alloca i8, align 1
		%3 = alloca **i8, align 8
		store %thread, %2
		store %value_ptr, %3
		%4 = load %2
		%5 = zext i8 %4 to i32
		%6 = icmp ne %5 123
		br %6, %7, %12
	7:
		%8 = load %2
		%9 = zext i8 %8 to i32
		%10 = icmp sgt %9 3
		br %10, %11, %12
	11:
		store 1, @__CS_error
		store 2, @__CS_ret
		store 0, %1
		br %49
	12:
		%13 = load %2
		%14 = zext i8 %13 to i32
		%15 = icmp eq %14 123
		br %15, %26, %16
	16:
		%17 = load %2
		%18 = zext i8 %17 to i64
		%19 = load @__CS_round
		%20 = zext i8 %19 to i64
		%21 = getelementptr @__CS_thread_status, 0, %20
		%22 = getelementptr %21, 0, %18
		%23 = load %22
		%24 = zext i8 %23 to i32
		%25 = icmp eq %24 1
		br %25, %26, %27
	26:
		store 1, @__CS_ret
		store 0, %1
		br %49
	27:
		%28 = load %2
		%29 = zext i8 %28 to i64
		%30 = load @__CS_round
		%31 = zext i8 %30 to i64
		%32 = getelementptr @__CS_thread_status, 0, %31
		%33 = getelementptr %32, 0, %29
		%34 = load %33
		%35 = zext i8 %34 to i32
		%36 = icmp eq %35 0
		br %36, %37, %38
	37:
		store 1, @__CS_error
		store 2, @__CS_ret
		store 0, %1
		br %49
	38:
		%39 = load %2
		%40 = zext i8 %39 to i64
		%41 = load @__CS_round
		%42 = zext i8 %41 to i64
		%43 = getelementptr @__CS_thread_status, 0, %42
		%44 = getelementptr %43, 0, %40
		%45 = load %44
		%46 = zext i8 %45 to i32
		%47 = icmp eq %46 2
		%48 = zext i1 %47 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %48)
		store 0, %1
		br %49
	49:
		%50 = load %1
		ret %50

*BasicFunctionTypename: "__CS_pthread_create" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: (id1 *i8, attr *i8, t1 *BasicFunctionType varArgs: falsereturnType: *i8paramTypes: (*i8), arg *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		%2 = alloca *i8, align 8
		%3 = alloca *i8, align 8
		%4 = alloca *BasicFunctionType varArgs: falsereturnType: *i8paramTypes: (*i8), align 8
		%5 = alloca *i8, align 8
		store %id1, %2
		store %attr, %3
		store %t1, %4
		store %arg, %5
		%6 = load @__CS_thread_index
		%7 = zext i8 %6 to i32
		%8 = icmp eq %7 2
		br %8, %9, %11
	9:
		%10 = load %2
		store 123, %10
		store -1, %1
		br %35
	11:
		%12 = load @__CS_thread_index
		%13 = add %12 1
		store %13, @__CS_thread_index
		%14 = load @__CS_thread_index
		%15 = zext i8 %14 to i64
		%16 = getelementptr @__CS_thread_allocated, 0, %15
		store 1, %16
		%17 = load @__CS_round
		%18 = load @__CS_thread_index
		%19 = zext i8 %18 to i64
		%20 = getelementptr @__CS_thread_born_round, 0, %19
		store %17, %20
		%21 = load %4
		%22 = load @__CS_thread_index
		%23 = zext i8 %22 to i64
		%24 = getelementptr @__CS_thread, 0, %23
		store %21, %24
		%25 = load @__CS_thread_index
		%26 = zext i8 %25 to i64
		%27 = load @__CS_round
		%28 = zext i8 %27 to i64
		%29 = getelementptr @__CS_thread_status, 0, %28
		%30 = getelementptr %29, 0, %26
		store 1, %30
		%31 = load @__CS_thread_index
		%32 = load %2
		store %31, %32
		%33 = load @__CS_thread_index
		%34 = zext i8 %33 to i32
		store %34, %1
		br %35
	35:
		%36 = load %1
		ret %36

*BasicFunctionTypename: "thread1" linkageType: EXTERNALLY_VISIBLE returnParam: *i8 parameters: (arg *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca *i8, align 8
		%2 = alloca *i8, align 8
		store %arg, %2
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%3 = load @__CS_ret
		%4 = zext i8 %3 to i32
		%5 = icmp ne %4 0
		br %5, %6, %7
	6:
		store null, %1
		br %63
	7:
		%8 = load @__CS_round
		%9 = zext i8 %8 to i64
		%10 = getelementptr @ma, 0, %9
		%11 = call i32 @__CS_pthread_mutex_lock(*i8 %10)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%12 = load @__CS_ret
		%13 = zext i8 %12 to i32
		%14 = icmp ne %13 0
		br %14, %15, %16
	15:
		store null, %1
		br %63
	16:
		%17 = load @__CS_round
		%18 = zext i8 %17 to i64
		%19 = getelementptr @data1, 0, %18
		%20 = load %19
		%21 = add %20 1
		store %21, %19
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%22 = load @__CS_ret
		%23 = zext i8 %22 to i32
		%24 = icmp ne %23 0
		br %24, %25, %26
	25:
		store null, %1
		br %63
	26:
		%27 = load @__CS_round
		%28 = zext i8 %27 to i64
		%29 = getelementptr @ma, 0, %28
		%30 = call i32 @__CS_pthread_mutex_unlock(*i8 %29)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%31 = load @__CS_ret
		%32 = zext i8 %31 to i32
		%33 = icmp ne %32 0
		br %33, %34, %35
	34:
		store null, %1
		br %63
	35:
		%36 = load @__CS_round
		%37 = zext i8 %36 to i64
		%38 = getelementptr @ma, 0, %37
		%39 = call i32 @__CS_pthread_mutex_lock(*i8 %38)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%40 = load @__CS_ret
		%41 = zext i8 %40 to i32
		%42 = icmp ne %41 0
		br %42, %43, %44
	43:
		store null, %1
		br %63
	44:
		%45 = load @__CS_round
		%46 = zext i8 %45 to i64
		%47 = getelementptr @data2, 0, %46
		%48 = load %47
		%49 = add %48 1
		store %49, %47
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%50 = load @__CS_ret
		%51 = zext i8 %50 to i32
		%52 = icmp ne %51 0
		br %52, %53, %54
	53:
		store null, %1
		br %63
	54:
		%55 = load @__CS_round
		%56 = zext i8 %55 to i64
		%57 = getelementptr @ma, 0, %56
		%58 = call i32 @__CS_pthread_mutex_unlock(*i8 %57)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%59 = load @__CS_ret
		%60 = zext i8 %59 to i32
		%61 = icmp ne %60 0
		br %61, %62, %63
	62:
		store null, %1
		br %63
	63:
		%64 = load %1
		ret %64

*BasicFunctionTypename: "thread2" linkageType: EXTERNALLY_VISIBLE returnParam: *i8 parameters: (arg *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca *i8, align 8
		%2 = alloca *i8, align 8
		store %arg, %2
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%3 = load @__CS_ret
		%4 = zext i8 %3 to i32
		%5 = icmp ne %4 0
		br %5, %6, %7
	6:
		store null, %1
		br %63
	7:
		%8 = load @__CS_round
		%9 = zext i8 %8 to i64
		%10 = getelementptr @ma, 0, %9
		%11 = call i32 @__CS_pthread_mutex_lock(*i8 %10)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%12 = load @__CS_ret
		%13 = zext i8 %12 to i32
		%14 = icmp ne %13 0
		br %14, %15, %16
	15:
		store null, %1
		br %63
	16:
		%17 = load @__CS_round
		%18 = zext i8 %17 to i64
		%19 = getelementptr @data1, 0, %18
		%20 = load %19
		%21 = add %20 5
		store %21, %19
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%22 = load @__CS_ret
		%23 = zext i8 %22 to i32
		%24 = icmp ne %23 0
		br %24, %25, %26
	25:
		store null, %1
		br %63
	26:
		%27 = load @__CS_round
		%28 = zext i8 %27 to i64
		%29 = getelementptr @ma, 0, %28
		%30 = call i32 @__CS_pthread_mutex_unlock(*i8 %29)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%31 = load @__CS_ret
		%32 = zext i8 %31 to i32
		%33 = icmp ne %32 0
		br %33, %34, %35
	34:
		store null, %1
		br %63
	35:
		%36 = load @__CS_round
		%37 = zext i8 %36 to i64
		%38 = getelementptr @ma, 0, %37
		%39 = call i32 @__CS_pthread_mutex_lock(*i8 %38)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%40 = load @__CS_ret
		%41 = zext i8 %40 to i32
		%42 = icmp ne %41 0
		br %42, %43, %44
	43:
		store null, %1
		br %63
	44:
		%45 = load @__CS_round
		%46 = zext i8 %45 to i64
		%47 = getelementptr @data2, 0, %46
		%48 = load %47
		%49 = sub %48 6
		store %49, %47
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%50 = load @__CS_ret
		%51 = zext i8 %50 to i32
		%52 = icmp ne %51 0
		br %52, %53, %54
	53:
		store null, %1
		br %63
	54:
		%55 = load @__CS_round
		%56 = zext i8 %55 to i64
		%57 = getelementptr @ma, 0, %56
		%58 = call i32 @__CS_pthread_mutex_unlock(*i8 %57)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%59 = load @__CS_ret
		%60 = zext i8 %59 to i32
		%61 = icmp ne %60 0
		br %61, %62, %63
	62:
		store null, %1
		br %63
	63:
		%64 = load %1
		ret %64

*BasicFunctionTypename: "main_thread" linkageType: EXTERNALLY_VISIBLE returnParam: *i8 parameters: (arg *i8) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca *i8, align 8
		%2 = alloca *i8, align 8
		%t1 = alloca i8, align 1
		%t2 = alloca i8, align 1
		store %arg, %2
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%3 = load @__CS_ret
		%4 = zext i8 %3 to i32
		%5 = icmp ne %4 0
		br %5, %6, %7
	6:
		store null, %1
		br %91
	7:
		%8 = load @__CS_round
		%9 = zext i8 %8 to i64
		%10 = getelementptr @ma, 0, %9
		%11 = call i32 @__CS_pthread_mutex_init(*i8 %10, *i8 null)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%12 = load @__CS_ret
		%13 = zext i8 %12 to i32
		%14 = icmp ne %13 0
		br %14, %15, %16
	15:
		store null, %1
		br %91
	16:
		%17 = load @__CS_round
		%18 = zext i8 %17 to i64
		%19 = getelementptr @mb, 0, %18
		%20 = call i32 @__CS_pthread_mutex_init(*i8 %19, *i8 null)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%21 = load @__CS_ret
		%22 = zext i8 %21 to i32
		%23 = icmp ne %22 0
		br %23, %24, %25
	24:
		store null, %1
		br %91
	25:
		%26 = load @__CS_round
		%27 = zext i8 %26 to i64
		%28 = getelementptr @data1, 0, %27
		store 10, %28
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%29 = load @__CS_ret
		%30 = zext i8 %29 to i32
		%31 = icmp ne %30 0
		br %31, %32, %33
	32:
		store null, %1
		br %91
	33:
		%34 = load @__CS_round
		%35 = zext i8 %34 to i64
		%36 = getelementptr @data2, 0, %35
		store 10, %36
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%37 = load @__CS_ret
		%38 = zext i8 %37 to i32
		%39 = icmp ne %38 0
		br %39, %40, %41
	40:
		store null, %1
		br %91
	41:
		%42 = call i32 @__CS_pthread_create(*i8 %t1, *i8 null, *BasicFunctionType varArgs: falsereturnType: *i8paramTypes: (*i8) @thread1, *i8 null)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%43 = load @__CS_ret
		%44 = zext i8 %43 to i32
		%45 = icmp ne %44 0
		br %45, %46, %47
	46:
		store null, %1
		br %91
	47:
		%48 = call i32 @__CS_pthread_create(*i8 %t2, *i8 null, *BasicFunctionType varArgs: falsereturnType: *i8paramTypes: (*i8) @thread2, *i8 null)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%49 = load @__CS_ret
		%50 = zext i8 %49 to i32
		%51 = icmp ne %50 0
		br %51, %52, %53
	52:
		store null, %1
		br %91
	53:
		%54 = load %t1
		%55 = call i32 @__CS_pthread_join(i8 zeroext %54, **i8 null)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%56 = load @__CS_ret
		%57 = zext i8 %56 to i32
		%58 = icmp ne %57 0
		br %58, %59, %60
	59:
		store null, %1
		br %91
	60:
		%61 = load %t2
		%62 = call i32 @__CS_pthread_join(i8 zeroext %61, **i8 null)
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%63 = load @__CS_ret
		%64 = zext i8 %63 to i32
		%65 = icmp ne %64 0
		br %65, %66, %67
	66:
		store null, %1
		br %91
	67:
		%68 = load @__CS_round
		%69 = zext i8 %68 to i64
		%70 = getelementptr @data1, 0, %69
		%71 = load %70
		%72 = icmp eq %71 16
		br %72, %73, %86
	73:
		%74 = load @__CS_round
		%75 = zext i8 %74 to i64
		%76 = getelementptr @data2, 0, %75
		%77 = load %76
		%78 = icmp eq %77 5
		br %78, %79, %86
	79:
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%80 = load @__CS_ret
		%81 = zext i8 %80 to i32
		%82 = icmp ne %81 0
		br %82, %83, %84
	83:
		store null, %1
		br %91
	84:
		br %85
	85:
		store 1, @__CS_error
		store 2, @__CS_ret
		store null, %1
		br %91
	86:
		Unnamed Call-Instruction = call BasicVoidType @__CS_cs()
		%87 = load @__CS_ret
		%88 = zext i8 %87 to i32
		%89 = icmp ne %88 0
		br %89, %90, %91
	90:
		store null, %1
		br %91
	91:
		%92 = load %1
		ret %92

*BasicFunctionTypename: "main" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: () variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		%__CS_cp___CS_thread_status = alloca [2 x [3 x i8]], align 1
		%__CS_cp___CS_thread_lockedon = alloca [2 x [3 x *i8]], align 16
		%__CS_cp_ma = alloca [2 x i8], align 1
		%__CS_cp_mb = alloca [2 x i8], align 1
		%__CS_cp_data1 = alloca [2 x i32], align 4
		%__CS_cp_data2 = alloca [2 x i32], align 4
		store 0, %1
		%2 = getelementptr %__CS_cp___CS_thread_status, 0, 1
		%3 = getelementptr %2, 0, 0
		%4 = load %3
		store %4, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@6fdb0111
		%5 = getelementptr %__CS_cp___CS_thread_status, 0, 1
		%6 = getelementptr %5, 0, 1
		%7 = load %6
		store %7, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@611cf29a
		%8 = getelementptr %__CS_cp___CS_thread_status, 0, 1
		%9 = getelementptr %8, 0, 2
		%10 = load %9
		store %10, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@65236a61
		%11 = getelementptr %__CS_cp___CS_thread_lockedon, 0, 1
		%12 = getelementptr %11, 0, 0
		%13 = load %12
		store %13, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@2021f8a1
		%14 = getelementptr %__CS_cp___CS_thread_lockedon, 0, 1
		%15 = getelementptr %14, 0, 1
		%16 = load %15
		store %16, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@1745b63d
		%17 = getelementptr %__CS_cp___CS_thread_lockedon, 0, 1
		%18 = getelementptr %17, 0, 2
		%19 = load %18
		store %19, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@11cb1e6d
		%20 = getelementptr %__CS_cp_ma, 0, 1
		%21 = load %20
		store %21, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@6f450e57
		%22 = getelementptr %__CS_cp_mb, 0, 1
		%23 = load %22
		store %23, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@400e07ee
		%24 = getelementptr %__CS_cp_data1, 0, 1
		%25 = load %24
		store %25, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@7ac0a58c
		%26 = getelementptr %__CS_cp_data2, 0, 1
		%27 = load %26
		store %27, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@33b1e4cf
		store 0, @__CS_round
		store 0, @__CS_thread_index
		%28 = load @__CS_round
		store %28, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@74416358
		store 1, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@44403b49
		store @main_thread, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@3bd30a88
		store 1, aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@7f816a1
		%29 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@785ceea5
		%30 = zext i8 %29 to i32
		%31 = icmp eq %30 1
		br %31, %32, %45
	32:
		%33 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@3d031894
		store %33, @__CS_round
		store 0, @__CS_ret
		%34 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@1ea7d2f6
		%35 = call *i8 %34(*i8 null)
		%36 = load @__CS_ret
		%37 = zext i8 %36 to i32
		%38 = icmp ne %37 1
		br %38, %39, %44
	39:
		%40 = load @__CS_round
		%41 = zext i8 %40 to i64
		%42 = getelementptr @__CS_thread_status, 0, %41
		%43 = getelementptr %42, 0, 0
		store 2, %43
		br %44
	44:
		br %45
	45:
		%46 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@592d829d
		%47 = zext i8 %46 to i32
		%48 = icmp eq %47 1
		br %48, %49, %62
	49:
		%50 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@461b76db
		store %50, @__CS_round
		store 0, @__CS_ret
		%51 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@63f91134
		%52 = call *i8 %51(*i8 null)
		%53 = load @__CS_ret
		%54 = zext i8 %53 to i32
		%55 = icmp ne %54 1
		br %55, %56, %61
	56:
		%57 = load @__CS_round
		%58 = zext i8 %57 to i64
		%59 = getelementptr @__CS_thread_status, 0, %58
		%60 = getelementptr %59, 0, 1
		store 2, %60
		br %61
	61:
		br %62
	62:
		%63 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@43e95fdf
		%64 = zext i8 %63 to i32
		%65 = icmp eq %64 1
		br %65, %66, %79
	66:
		%67 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@76651455
		store %67, @__CS_round
		store 0, @__CS_ret
		%68 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@6bd519ec
		%69 = call *i8 %68(*i8 null)
		%70 = load @__CS_ret
		%71 = zext i8 %70 to i32
		%72 = icmp ne %71 1
		br %72, %73, %78
	73:
		%74 = load @__CS_round
		%75 = zext i8 %74 to i64
		%76 = getelementptr @__CS_thread_status, 0, %75
		%77 = getelementptr %76, 0, 2
		store 2, %77
		br %78
	78:
		br %79
	79:
		%80 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@408ed513
		%81 = zext i8 %80 to i32
		%82 = getelementptr %__CS_cp___CS_thread_status, 0, 1
		%83 = getelementptr %82, 0, 0
		%84 = load %83
		%85 = zext i8 %84 to i32
		%86 = icmp eq %81 %85
		%87 = zext i1 %86 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %87)
		%88 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@49106d7a
		%89 = zext i8 %88 to i32
		%90 = getelementptr %__CS_cp___CS_thread_status, 0, 1
		%91 = getelementptr %90, 0, 1
		%92 = load %91
		%93 = zext i8 %92 to i32
		%94 = icmp eq %89 %93
		%95 = zext i1 %94 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %95)
		%96 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@17890fb1
		%97 = zext i8 %96 to i32
		%98 = getelementptr %__CS_cp___CS_thread_status, 0, 1
		%99 = getelementptr %98, 0, 2
		%100 = load %99
		%101 = zext i8 %100 to i32
		%102 = icmp eq %97 %101
		%103 = zext i1 %102 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %103)
		%104 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@54507ed5
		%105 = getelementptr %__CS_cp___CS_thread_lockedon, 0, 1
		%106 = getelementptr %105, 0, 0
		%107 = load %106
		%108 = icmp eq %104 %107
		%109 = zext i1 %108 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %109)
		%110 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@62401f01
		%111 = getelementptr %__CS_cp___CS_thread_lockedon, 0, 1
		%112 = getelementptr %111, 0, 1
		%113 = load %112
		%114 = icmp eq %110 %113
		%115 = zext i1 %114 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %115)
		%116 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@2871d58e
		%117 = getelementptr %__CS_cp___CS_thread_lockedon, 0, 1
		%118 = getelementptr %117, 0, 2
		%119 = load %118
		%120 = icmp eq %116 %119
		%121 = zext i1 %120 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %121)
		%122 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@775aa3b6
		%123 = zext i8 %122 to i32
		%124 = getelementptr %__CS_cp_ma, 0, 1
		%125 = load %124
		%126 = zext i8 %125 to i32
		%127 = icmp eq %123 %126
		%128 = zext i1 %127 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %128)
		%129 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@202bcd5e
		%130 = zext i8 %129 to i32
		%131 = getelementptr %__CS_cp_mb, 0, 1
		%132 = load %131
		%133 = zext i8 %132 to i32
		%134 = icmp eq %130 %133
		%135 = zext i1 %134 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %135)
		%136 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@42f1664d
		%137 = getelementptr %__CS_cp_data1, 0, 1
		%138 = load %137
		%139 = icmp eq %136 %138
		%140 = zext i1 %139 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %140)
		%141 = load aprove.InputModules.Programs.llvm.internalStructures.literals.const_expr.LLVMGetElementPtrConstExpr@648a1638
		%142 = getelementptr %__CS_cp_data2, 0, 1
		%143 = load %142
		%144 = icmp eq %141 %143
		%145 = zext i1 %144 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assume(i32 %145)
		%146 = load @__CS_error
		%147 = zext i8 %146 to i32
		%148 = icmp ne %147 1
		%149 = zext i1 %148 to i32
		Unnamed Call-Instruction = call BasicVoidType @__VERIFIER_assert(i32 %149)
		%150 = load %1
		ret %150


Analyze Termination of all function calls matching the pattern:
main()