[WARNING] Global which is neither Integer nor Float
@.str = private unnamed_addr constant [2 x i8] c"0\00", align 1
It is not being monitored (there may be errors en route)
[WARNING] Global which is neither Integer nor Float
@.str.1 = private unnamed_addr constant [7 x i8] c"main.c\00", align 1
It is not being monitored (there may be errors en route)
[WARNING] Global which is neither Integer nor Float
@__PRETTY_FUNCTION__.f1 = private unnamed_addr constant [17 x i8] c"void *f1(void *)\00", align 1
It is not being monitored (there may be errors en route)
[WARNING] Global which is neither Integer nor Float
@__PRETTY_FUNCTION__.f2 = private unnamed_addr constant [17 x i8] c"void *f2(void *)\00", align 1
It is not being monitored (there may be errors en route)
Rules: (declare-rel ld ((_ BitVec 16) (_ BitVec 16)))
(declare-rel dom ((_ BitVec 16) (_ BitVec 16)))
(declare-rel postDom ((_ BitVec 16) (_ BitVec 16)))
(declare-rel st ((_ BitVec 16) (_ BitVec 16)))
(declare-var A (_ BitVec 16))
(declare-var B (_ BitVec 16))
(declare-var C (_ BitVec 16))
(rule (=> (and (dom B C) (dom A B)) (dom A C)))
(rule (=> (and (postDom B C) (postDom A B)) (postDom A C)))
(rule (postDom #x0017 #x0016))
(rule (dom #x0016 #x0017))
(rule (dom #x0009 #x000a))
(rule (postDom #x000a #x0009))
(rule (dom #x000a #x000b))
(rule (postDom #x000b #x000a))
(rule (st #x0009 #x000c))
(rule (ld #x000a #x000c))
(rule (postDom #x000d #x000b))
(rule (dom #x000b #x000e))
(rule (dom #x000b #x000d))
(rule (dom #x000e #x000f))
(rule (postDom #x000f #x000e))
(rule (dom #x0010 #x0011))
(rule (postDom #x0011 #x0010))
(rule (dom #x0011 #x0012))
(rule (postDom #x0012 #x0011))
(rule (dom #x0012 #x0013))
(rule (postDom #x0013 #x0012))
(rule (st #x0010 #x0014))
(rule (st #x0011 #x000c))
(rule (ld #x0012 #x0014))
(rule (postDom #x0015 #x0013))
(rule (dom #x0013 #x0016))
(rule (dom #x0013 #x0015))

[WARNING] Initializing unhandled global type: @.str = private unnamed_addr constant [2 x i8] c"0\00", align 1
Setting to default initial value
[WARNING] Initializing unhandled global type: @.str.1 = private unnamed_addr constant [7 x i8] c"main.c\00", align 1
Setting to default initial value
[WARNING] Initializing unhandled global type: @__PRETTY_FUNCTION__.f1 = private unnamed_addr constant [17 x i8] c"void *f1(void *)\00", align 1
Setting to default initial value
[WARNING] Initializing unhandled global type: @__PRETTY_FUNCTION__.f2 = private unnamed_addr constant [17 x i8] c"void *f2(void *)\00", align 1
Setting to default initial value
Interference Iteration: 1
Analyzing thread: 0
Analyzing thread: 1
Analyzing thread: 2
Interference Iteration: 2
Analyzing thread: 0
Analyzing thread: 1
Analyzing thread: 2
v6: @a = common global i32 0, align 4
v7: @b = common global i32 0, align 4
v8: i8* %unused
v0:   %0 = load i32, i32* @a, align 4
v1:   %cmp = icmp ne i32 %0, 1
v10: i8* %1
v11: i32 %2
v9: i8* %0
v12: i8* %3
v13: i8* %unused
v2:   %0 = load i32, i32* @b, align 4
v3:   %cmp = icmp ne i32 %0, 0
v14: i64* %0
v15: %union.pthread_attr_t* %1
v4:   %t1 = alloca i64, align 8
v5:   %t2 = alloca i64, align 8
v16: i8* (i8*)* %2
v17: i8* %3
==== f1() Results ====
BasicBlock: 
entry:
  store i32 1, i32* @a, align 4
  %0 = load i32, i32* @a, align 4
  %cmp = icmp ne i32 %0, 1
  br i1 %cmp, label %if.then, label %if.end
Facts: interval of dim (18,0):
      v0 in [-oo,+oo]
      v1 in [-oo,+oo]
     v10 in [-oo,+oo]
     v11 in [-oo,+oo]
     v12 in [-oo,+oo]
     v13 in [-oo,+oo]
     v14 in [-oo,+oo]
     v15 in [-oo,+oo]
     v16 in [-oo,+oo]
     v17 in [-oo,+oo]
      v2 in [-oo,+oo]
      v3 in [-oo,+oo]
      v4 in [-oo,+oo]
      v5 in [-oo,+oo]
      v6 in [0,0]
      v7 in [0,0]
      v8 in [-oo,+oo]
      v9 in [-oo,+oo]

BasicBlock: 
if.then:                                          ; preds = %entry
  call void @__assert_fail(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i32 0, i32 0), i32 18, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @__PRETTY_FUNCTION__.f1, i32 0, i32 0)) #3
  unreachable
Facts: interval of dim (18,0): bottom

BasicBlock: 
if.end:                                           ; preds = %entry
  ret i8* null
Facts: interval of dim (18,0):
      v0 in [1,1]
      v1 in [0,0]
     v10 in [-oo,+oo]
     v11 in [-oo,+oo]
     v12 in [-oo,+oo]
     v13 in [-oo,+oo]
     v14 in [-oo,+oo]
     v15 in [-oo,+oo]
     v16 in [-oo,+oo]
     v17 in [-oo,+oo]
      v2 in [-oo,+oo]
      v3 in [-oo,+oo]
      v4 in [-oo,+oo]
      v5 in [-oo,+oo]
      v6 in [1,1]
      v7 in [0,0]
      v8 in [-oo,+oo]
      v9 in [-oo,+oo]

======================
==== f2() Results ====
BasicBlock: 
entry:
  store i32 0, i32* @b, align 4
  store i32 2, i32* @a, align 4
  %0 = load i32, i32* @b, align 4
  %cmp = icmp ne i32 %0, 0
  br i1 %cmp, label %if.then, label %if.end
Facts: interval of dim (18,0):
      v0 in [-oo,+oo]
      v1 in [-oo,+oo]
     v10 in [-oo,+oo]
     v11 in [-oo,+oo]
     v12 in [-oo,+oo]
     v13 in [-oo,+oo]
     v14 in [-oo,+oo]
     v15 in [-oo,+oo]
     v16 in [-oo,+oo]
     v17 in [-oo,+oo]
      v2 in [-oo,+oo]
      v3 in [-oo,+oo]
      v4 in [-oo,+oo]
      v5 in [-oo,+oo]
      v6 in [0,0]
      v7 in [0,0]
      v8 in [-oo,+oo]
      v9 in [-oo,+oo]

BasicBlock: 
if.then:                                          ; preds = %entry
  call void @__assert_fail(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i32 0, i32 0), i32 33, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @__PRETTY_FUNCTION__.f2, i32 0, i32 0)) #3
  unreachable
Facts: interval of dim (18,0): bottom

BasicBlock: 
if.end:                                           ; preds = %entry
  ret i8* null
Facts: interval of dim (18,0):
      v0 in [-oo,+oo]
      v1 in [-oo,+oo]
     v10 in [-oo,+oo]
     v11 in [-oo,+oo]
     v12 in [-oo,+oo]
     v13 in [-oo,+oo]
     v14 in [-oo,+oo]
     v15 in [-oo,+oo]
     v16 in [-oo,+oo]
     v17 in [-oo,+oo]
      v2 in [0,0]
      v3 in [0,0]
      v4 in [-oo,+oo]
      v5 in [-oo,+oo]
      v6 in [2,2]
      v7 in [0,0]
      v8 in [-oo,+oo]
      v9 in [-oo,+oo]

======================
==== main() Results ====
BasicBlock: 
entry:
  %t1 = alloca i64, align 8
  %t2 = alloca i64, align 8
  %call = call i32 @pthread_create(i64* %t1, %union.pthread_attr_t* null, i8* (i8*)* @f1, i8* null) #3
  %call1 = call i32 @pthread_create(i64* %t2, %union.pthread_attr_t* null, i8* (i8*)* @f2, i8* null) #3
  ret i32 0
Facts: interval of dim (18,0):
      v0 in [-oo,+oo]
      v1 in [-oo,+oo]
     v10 in [-oo,+oo]
     v11 in [-oo,+oo]
     v12 in [-oo,+oo]
     v13 in [-oo,+oo]
     v14 in [-oo,+oo]
     v15 in [-oo,+oo]
     v16 in [-oo,+oo]
     v17 in [-oo,+oo]
      v2 in [-oo,+oo]
      v3 in [-oo,+oo]
      v4 in [-oo,+oo]
      v5 in [-oo,+oo]
      v6 in [0,0]
      v7 in [0,0]
      v8 in [-oo,+oo]
      v9 in [-oo,+oo]

======================
[WARNING] Value not dumped to metadata: @a = common global i32 0, align 4
	type not handled
[WARNING] Value not dumped to metadata: @b = common global i32 0, align 4
	type not handled
Errors found: 0
Max Permutations: 0
Total pairs: 0
Filtered pairs: 0