int main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
r1 = __VERIFIER_nondet_uchar();
id1 = __VERIFIER_nondet_char();
st1 = __VERIFIER_nondet_char();
send1 = __VERIFIER_nondet_char();
mode1 = __VERIFIER_nondet_bool();
alive1 = __VERIFIER_nondet_bool();
id2 = __VERIFIER_nondet_char();
st2 = __VERIFIER_nondet_char();
send2 = __VERIFIER_nondet_char();
mode2 = __VERIFIER_nondet_bool();
alive2 = __VERIFIER_nondet_bool();
id3 = __VERIFIER_nondet_char();
st3 = __VERIFIER_nondet_char();
send3 = __VERIFIER_nondet_char();
mode3 = __VERIFIER_nondet_bool();
alive3 = __VERIFIER_nondet_bool();
id4 = __VERIFIER_nondet_char();
st4 = __VERIFIER_nondet_char();
send4 = __VERIFIER_nondet_char();
mode4 = __VERIFIER_nondet_bool();
alive4 = __VERIFIER_nondet_bool();
i2 = init();
__VERIFIER_assume(i2);
p1_old = nomsg;
p1_new = nomsg;
p2_old = nomsg;
p2_new = nomsg;
p3_old = nomsg;
p3_new = nomsg;
p4_old = nomsg;
p4_new = nomsg;
i2 = 0;
while (1) {
{
node1();
node2();
node3();
node4();
p1_old = p1_new;
p1_new = nomsg;
p2_old = p2_new;
p2_new = nomsg;
p3_old = p3_new;
p3_new = nomsg;
p4_old = p4_new;
p4_new = nomsg;
c1 = check();
assert(c1);
}
}
}
return 0;
}
void __CS_cs(void)
{
__CS_type k = __VERIFIER_nondet_uchar();
__VERIFIER_assume(__CS_round+k < __CS_ROUNDS); // k==0 --> no switch
__CS_round += k;
// this is removed when not needed
// __CS_ret = (__VERIFIER_nondet_int() && __CS_round == __CS_ROUNDS-1)?1:__CS_ret; // preemption
__CS_ret = (__VERIFIER_nondet_int() && __CS_round == __CS_ROUNDS-1)?__CS_ret_PREEMPTED:__CS_ret;
}
u8 dca3_get_tag(struct device *arg0, int arg1) {
// Typedef type
// Real type: unsigned char
// Simple type
return __VERIFIER_nondet_uchar();
}
/* these type are not sane, but benchmarks use them */
unsigned int __VERIFIER_nondet_U8()
{
return __VERIFIER_nondet_uchar();
}
int main(void) {
char x1 = __VERIFIER_nondet_char();
assert(x1 >= SCHAR_MIN && x1 <= SCHAR_MAX);
signed char x2 = __VERIFIER_nondet_signed_char();
assert(x2 >= SCHAR_MIN && x2 <= SCHAR_MAX);
unsigned char x3 = __VERIFIER_nondet_unsigned_char();
assert(x3 >= 0 && x3 <= UCHAR_MAX);
short x4 = __VERIFIER_nondet_short();
assert(x4 >= SHRT_MIN && x4 <= SHRT_MAX);
signed short x5 = __VERIFIER_nondet_signed_short();
assert(x5 >= SHRT_MIN && x5 <= SHRT_MAX);
signed short int x6 = __VERIFIER_nondet_signed_short_int();
assert(x6 >= SHRT_MIN && x6 <= SHRT_MAX);
unsigned short x7 = __VERIFIER_nondet_unsigned_short();
assert(x7 >= 0 && x7 <= USHRT_MAX);
unsigned short int x8 = __VERIFIER_nondet_unsigned_short_int();
assert(x8 >= 0 && x8 <= USHRT_MAX);
int x9 = __VERIFIER_nondet_int();
assert(x9 >= INT_MIN && x9 <= INT_MAX);
signed int x10 = __VERIFIER_nondet_signed_int();
assert(x10 >= INT_MIN && x10 <= INT_MAX);
unsigned x11 = __VERIFIER_nondet_unsigned();
assert(x11 >= 0 && x11 <= UINT_MAX);
unsigned int x12 = __VERIFIER_nondet_unsigned_int();
assert(x12 >= 0 && x12 <= UINT_MAX);
long x13 = __VERIFIER_nondet_long();
assert(x13 >= LONG_MIN && x13 <= LONG_MAX);
long int x14 = __VERIFIER_nondet_long_int();
assert(x14 >= LONG_MIN && x14 <= LONG_MAX);
signed long x15 = __VERIFIER_nondet_signed_long();
assert(x15 >= LONG_MIN && x15 <= LONG_MAX);
signed long int x16 = __VERIFIER_nondet_signed_long_int();
assert(x16 >= LONG_MIN && x16 <= LONG_MAX);
unsigned long x17 = __VERIFIER_nondet_unsigned_long();
assert(x17 >= 0 && x17 <= ULONG_MAX);
unsigned long int x18 = __VERIFIER_nondet_unsigned_long_int();
assert(x18 >= 0 && x18 <= ULONG_MAX);
long long x19 = __VERIFIER_nondet_long_long();
assert(x19 >= LLONG_MIN && x19 <= LLONG_MAX);
long long int x20 = __VERIFIER_nondet_long_long_int();
assert(x20 >= LLONG_MIN && x20 <= LLONG_MAX);
signed long long x21 = __VERIFIER_nondet_signed_long_long();
assert(x21 >= LLONG_MIN && x21 <= LLONG_MAX);
signed long long int x22 = __VERIFIER_nondet_signed_long_long_int();
assert(x22 >= LLONG_MIN && x22 <= LLONG_MAX);
unsigned long long x23 = __VERIFIER_nondet_unsigned_long_long();
assert(x23 >= 0 && x23 <= ULLONG_MAX);
unsigned long long int x24 = __VERIFIER_nondet_unsigned_long_long_int();
assert(x24 >= 0 && x24 <= ULLONG_MAX);
// Used in SVCCOMP benchmarks
_Bool x25 = __VERIFIER_nondet_bool();
assert(x25 == 0 || x25 == 1);
unsigned char x26 = __VERIFIER_nondet_uchar();
assert(x26 >= 0 && x26 <= UCHAR_MAX);
unsigned short x27 = __VERIFIER_nondet_ushort();
assert(x27 >= 0 && x27 <= USHRT_MAX);
unsigned int x28 = __VERIFIER_nondet_uint();
assert(x28 >= 0 && x28 <= UINT_MAX);
unsigned long x29 = __VERIFIER_nondet_ulong();
assert(x29 >= 0 && x29 <= ULONG_MAX);
return 0;
}
int main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
ep12 = __VERIFIER_nondet_bool();
ep13 = __VERIFIER_nondet_bool();
ep21 = __VERIFIER_nondet_bool();
ep23 = __VERIFIER_nondet_bool();
ep31 = __VERIFIER_nondet_bool();
ep32 = __VERIFIER_nondet_bool();
id1 = __VERIFIER_nondet_char();
r1 = __VERIFIER_nondet_uchar();
st1 = __VERIFIER_nondet_char();
nl1 = __VERIFIER_nondet_char();
m1 = __VERIFIER_nondet_char();
max1 = __VERIFIER_nondet_char();
mode1 = __VERIFIER_nondet_bool();
newmax1 = __VERIFIER_nondet_bool();
id2 = __VERIFIER_nondet_char();
r2 = __VERIFIER_nondet_uchar();
st2 = __VERIFIER_nondet_char();
nl2 = __VERIFIER_nondet_char();
m2 = __VERIFIER_nondet_char();
max2 = __VERIFIER_nondet_char();
mode2 = __VERIFIER_nondet_bool();
newmax2 = __VERIFIER_nondet_bool();
id3 = __VERIFIER_nondet_char();
r3 = __VERIFIER_nondet_uchar();
st3 = __VERIFIER_nondet_char();
nl3 = __VERIFIER_nondet_char();
m3 = __VERIFIER_nondet_char();
max3 = __VERIFIER_nondet_char();
mode3 = __VERIFIER_nondet_bool();
newmax3 = __VERIFIER_nondet_bool();
i2 = init();
__VERIFIER_assume(i2);
p12_old = nomsg;
p12_new = nomsg;
p13_old = nomsg;
p13_new = nomsg;
p21_old = nomsg;
p21_new = nomsg;
p23_old = nomsg;
p23_new = nomsg;
p31_old = nomsg;
p31_new = nomsg;
p32_old = nomsg;
p32_new = nomsg;
i2 = 0;
while (1) {
{
node1();
node2();
node3();
p12_old = p12_new;
p12_new = nomsg;
p13_old = p13_new;
p13_new = nomsg;
p21_old = p21_new;
p21_new = nomsg;
p23_old = p23_new;
p23_new = nomsg;
p31_old = p31_new;
p31_new = nomsg;
p32_old = p32_new;
p32_new = nomsg;
c1 = check();
assert(c1);
}
}
}
return 0;
}
