int main() {
int length1 = __VERIFIER_nondet_int();
int length2 = __VERIFIER_nondet_int();
int length3 = __VERIFIER_nondet_int();
if (length1 < 1) {
length1 = 1;
}
if (length2 < 2) {
length2 = 2;
}
if (length3 < 1) {
length3 = 1;
}
if (length2 - length3 < length1 || length3 > length2) return 0;
char* nondetString1 = (char*) alloca(length1 * sizeof(char));
char* nondetString2 = (char*) alloca(length2 * sizeof(char));
for(int i = 0; i < length1 -1; i++)
{
nondetString1[i] = __VERIFIER_nondet_char();
}
for(int i = 0; i< length3 -1; i++)
{
nondetString2[i] = __VERIFIER_nondet_char();
}
nondetString1[length1-1] = '\0';
nondetString2[length3-1] = '\0';
cstrcat(nondetString2,nondetString1);
return 0;
}
int main() {
int length1 = __VERIFIER_nondet_int();
int length2 = __VERIFIER_nondet_int();
if (length1 < 1) {
length1 = 1;
}
if (length2 < 1) {
length2 = 1;
}
char* nondetString1 = (char*) alloca(length1 * sizeof(char));
char* nondetString2 = (char*) alloca(length2 * sizeof(char));
for(int i = 0; i < length1 - 1; i++)
{
nondetString1[i] = __VERIFIER_nondet_char();
}
for(int i = 0; i < length2 - 1; i++)
{
nondetString2[i] = __VERIFIER_nondet_char();
}
nondetString1[length1-1] = '\0';
nondetString2[length2-1] = '\0';
return cstrspn(nondetString1,nondetString2);
}
void main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
r1 = __VERIFIER_nondet_char();
id1 = __VERIFIER_nondet_char();
st1 = __VERIFIER_nondet_char();
send1 = __VERIFIER_nondet_msg_t();
mode1 = __VERIFIER_nondet__Bool();
alive1 = __VERIFIER_nondet__Bool();
id2 = __VERIFIER_nondet_char();
st2 = __VERIFIER_nondet_char();
send2 = __VERIFIER_nondet_msg_t();
mode2 = __VERIFIER_nondet__Bool();
alive2 = __VERIFIER_nondet__Bool();
id3 = __VERIFIER_nondet_char();
st3 = __VERIFIER_nondet_char();
send3 = __VERIFIER_nondet_msg_t();
mode3 = __VERIFIER_nondet__Bool();
alive3 = __VERIFIER_nondet__Bool();
id4 = __VERIFIER_nondet_char();
st4 = __VERIFIER_nondet_char();
send4 = __VERIFIER_nondet_msg_t();
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 (i2 < 8) {
{
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);
i2 ++;
}
}
}
}
int main()
{
signed char x = __VERIFIER_nondet_char();
signed char y = __VERIFIER_nondet_char();
signed char g;
if (y > 0 && x % y == 0) {
g = gcd_test(x, y);
__VERIFIER_assert(g == y);
}
return 0;
}
int main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
r1 = __VERIFIER_nondet_char();
id1 = __VERIFIER_nondet_char();
st1 = __VERIFIER_nondet_char();
send1 = __VERIFIER_nondet_char();
mode1 = __VERIFIER_nondet_bool();
id2 = __VERIFIER_nondet_char();
st2 = __VERIFIER_nondet_char();
send2 = __VERIFIER_nondet_char();
mode2 = __VERIFIER_nondet_bool();
id3 = __VERIFIER_nondet_char();
st3 = __VERIFIER_nondet_char();
send3 = __VERIFIER_nondet_char();
mode3 = __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;
i2 = 0;
while (i2 < 6) {
{
node1();
node2();
node3();
p1_old = p1_new;
p1_new = nomsg;
p2_old = p2_new;
p2_new = nomsg;
p3_old = p3_new;
p3_new = nomsg;
c1 = check();
assert(c1);
i2 ++;
}
}
}
return 0;
}
void gate3_each_pals_period(void)
{
int8_t next_state ;
msg_t tmp ;
int tmp___0 ;
{
gate3Failed = __VERIFIER_nondet_bool();
write_history_bool(2, gate3Failed);
if (gate3Failed) {
g3v_new = nomsg != nomsg && g3v_new == nomsg ? nomsg : g3v_new;
return;
}
tmp = __VERIFIER_nondet_char();
next_state = tmp;
if ((int )next_state == 0) {
tmp___0 = 1;
} else
if ((int )next_state == 1) {
tmp___0 = 1;
} else
if ((int )next_state == 2) {
tmp___0 = 1;
} else {
tmp___0 = 0;
}
__VERIFIER_assume((_Bool )tmp___0);
g3v_new = next_state != nomsg && g3v_new == nomsg ? next_state : g3v_new;
return;
}
}
main(void)
{
char input_string[MAX], vogal_array[]={'a','A','e','E','i','I','o','O','u','U','\0'};;
unsigned int i,j,cont, tam_string, n_caracter;
for(i=0;i<MAX;i++)
input_string[i] = __VERIFIER_nondet_char();
__VERIFIER_assume(input_string[MAX-1]=='\0');
n_caracter = 0;
while(input_string[n_caracter]!='\0')
n_caracter++;
cont = 0;
for(i=0;i<n_caracter;i++)
for(j=0;j<MAX/2;j++)
if(input_string[i] == vogal_array[j])
cont++;
i=0;
int cont_aux = 0;
while(input_string[i]!='\0')
{
for(j=0;j<MAX/2;j++)
{
if(input_string[i] == vogal_array[j])
cont_aux++;
}
i++;
}
__VERIFIER_assert(cont_aux==cont);
}
int main(void)
{
char string_entrada[MAX], vetor_vogais[]={'a','A','e','E','i','I','o','O','u','U','\0'};;
unsigned int i,j,cont, tam_string, n_caracter;
for(i=0;i<MAX;i++)
string_entrada[i] = __VERIFIER_nondet_char();
string_entrada[MAX-1]='\0';
n_caracter = 0;
while(string_entrada[n_caracter]!='\0')
n_caracter++;
cont = 0;
for(i=0;i<n_caracter;i++)
for(j=0;j<8;j++)
if(string_entrada[i] == vetor_vogais[j])
cont++;
i=0;
int cont_aux = 0;
while(string_entrada[i]!='\0')
{
for(j=0;j<10;j++)
{
if(string_entrada[i] == vetor_vogais[j])
cont_aux++;
}
i++;
}
__VERIFIER_assert(cont_aux==cont);
return 0;
}
int main()
{
int argc = __VERIFIER_nondet_int();
__VERIFIER_assume(argc >= 1 && argc <= 10000);
char **argv=malloc((argc+1)*sizeof(char*));
argv[argc]=0;
for(int i=0; i<argc; ++i)
{
// let's limit the size of arguments to 10, which is an
// underapproximation obviously
argv[i]=malloc(11);
argv[i][10] = 0;
for(int j=0; j<10; ++j)
argv[i][j]=__VERIFIER_nondet_char();
}
int res = __main(argc, argv);
// Free argv
for(int i=0; i<argc; ++i)
free(argv[i]);
free(argv);
return res;
}
int main(void)
{
char string_A[MAX], string_B[MAX];
int i, j, nc_A, nc_B, found=0;
for(i=0; i<MAX; i++)
string_A[i]=__VERIFIER_nondet_char();
__VERIFIER_assume(string_A[MAX-1]=='\0');
for(i=0; i<MAX; i++)
string_B[i]=__VERIFIER_nondet_char();
__VERIFIER_assume(string_B[MAX-1]=='\0');
nc_A = 0;
while(string_A[nc_A]!='\0')
nc_A++;
nc_B = 0;
while(string_B[nc_B]!='\0')
nc_B++;
__VERIFIER_assume(nc_B >= nc_A);
i=j=0;
while((i<nc_A) && (j<nc_B))
{
if(string_A[i] == string_B[j])
{
i++;
j++;
}
else
{
i = i-j+1;
j = 0;
}
}
found = (j>nc_B-1)<<i;
__VERIFIER_assert(found == 0 || found == 1);
}
int main ()
{
char A [LINE_LENGTH+1];
for (int i = 0; i < LINE_LENGTH; i++) {
A[i] = __VERIFIER_nondet_char();
}
A[LINE_LENGTH] = EOS;
parse_expression_list (A);
return 0;
}
void Console_task_each_pals_period(void)
{
msg_t manual_selection ;
char tmp ;
{
tmp = __VERIFIER_nondet_char();
manual_selection = tmp;
write_manual_selection_history(manual_selection);
cs1_new = manual_selection != nomsg && cs1_new == nomsg ? manual_selection : cs1_new;
cs2_new = manual_selection != nomsg && cs2_new == nomsg ? manual_selection : cs2_new;
manual_selection = (msg_t )0;
return;
}
}
int main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
gate1Failed = __VERIFIER_nondet_bool();
gate2Failed = __VERIFIER_nondet_bool();
gate3Failed = __VERIFIER_nondet_bool();
VALUE1 = __VERIFIER_nondet_char();
VALUE2 = __VERIFIER_nondet_char();
VALUE3 = __VERIFIER_nondet_char();
gate1Failed_History_0 = __VERIFIER_nondet_bool();
gate1Failed_History_1 = __VERIFIER_nondet_bool();
gate1Failed_History_2 = __VERIFIER_nondet_bool();
gate2Failed_History_0 = __VERIFIER_nondet_bool();
gate2Failed_History_1 = __VERIFIER_nondet_bool();
gate2Failed_History_2 = __VERIFIER_nondet_bool();
gate3Failed_History_0 = __VERIFIER_nondet_bool();
gate3Failed_History_1 = __VERIFIER_nondet_bool();
gate3Failed_History_2 = __VERIFIER_nondet_bool();
votedValue_History_0 = __VERIFIER_nondet_char();
votedValue_History_1 = __VERIFIER_nondet_char();
votedValue_History_2 = __VERIFIER_nondet_char();
i2 = init();
__VERIFIER_assume(i2);
g1v_old = nomsg;
g1v_new = nomsg;
g2v_old = nomsg;
g2v_new = nomsg;
g3v_old = nomsg;
g3v_new = nomsg;
i2 = 0;
while (i2 < 10) {
{
gate1_each_pals_period();
gate2_each_pals_period();
gate3_each_pals_period();
voter();
g1v_old = g1v_new;
g1v_new = nomsg;
g2v_old = g2v_new;
g2v_new = nomsg;
g3v_old = g3v_new;
g3v_new = nomsg;
c1 = check();
assert(c1);
i2 ++;
}
}
}
return 0;
}
int main()
{
int argc;
__VERIFIER_assume(argc>=0);
char **argv=malloc((argc+1)*sizeof(char*));
argv[argc]=0;
for(int i=0; i<argc; ++i)
{
// let's limit the size of arguments to 10, which is an
// underapproximation obviously
argv[i]=malloc(10);
for(int j=0; j<10; ++j)
argv[i][j]=__VERIFIER_nondet_char();
}
return __main(argc, argv);
}
ssize_t write_nvram(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
unsigned int i;
const char __user *p = buf;
char c = __VERIFIER_nondet_char();
if (!access_ok(VERIFY_READ, buf, count))
return -EFAULT;
if (*ppos >= nvram_len)
return 0;
for (i = *ppos; count > 0 && i < nvram_len; ++i, ++p, --count) {
if (__get_user(c, p))
return -EFAULT;
nvram_write_byte(c, i);
}
*ppos = i;
__VERIFIER_assert(*ppos == i);
return p - buf;
}
int main() {
signed char b = __VERIFIER_nondet_char();
if (b < 0) {
b = -b;
}
unsigned char a = b;
// set msb to 1;
b = b | 128;
a = a | 128;
if (a != b) {
ERROR:
return -1;
} else {
return 0;
}
}
int main() {
int MAX = __VERIFIER_nondet_uint();
char str1[MAX], str2[MAX];
int cont, i, j;
cont = 0;
for (i=0; i<MAX; i++) {
str1[i]=__VERIFIER_nondet_char();
}
str1[MAX-1]= '\0';
j = 0;
for (i = MAX - 1; i >= 0; i--) {
str2[j] = str1[0];
j++;
}
j = MAX-1;
for (i=0; i<MAX; i++) {
__VERIFIER_assert(str1[i] == str2[j]);
j--;
}
}
int main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
side1Failed = __VERIFIER_nondet_bool();
side2Failed = __VERIFIER_nondet_bool();
side1_written = __VERIFIER_nondet_char();
side2_written = __VERIFIER_nondet_char();
side1Failed_History_0 = __VERIFIER_nondet_bool();
side1Failed_History_1 = __VERIFIER_nondet_bool();
side1Failed_History_2 = __VERIFIER_nondet_bool();
side2Failed_History_0 = __VERIFIER_nondet_bool();
side2Failed_History_1 = __VERIFIER_nondet_bool();
side2Failed_History_2 = __VERIFIER_nondet_bool();
active_side_History_0 = __VERIFIER_nondet_char();
active_side_History_1 = __VERIFIER_nondet_char();
active_side_History_2 = __VERIFIER_nondet_char();
manual_selection_History_0 = __VERIFIER_nondet_char();
manual_selection_History_1 = __VERIFIER_nondet_char();
manual_selection_History_2 = __VERIFIER_nondet_char();
i2 = init();
__VERIFIER_assume(i2);
cs1_old = nomsg;
cs1_new = nomsg;
cs2_old = nomsg;
cs2_new = nomsg;
s1s2_old = nomsg;
s1s2_new = nomsg;
s1s1_old = nomsg;
s1s1_new = nomsg;
s2s1_old = nomsg;
s2s1_new = nomsg;
s2s2_old = nomsg;
s2s2_new = nomsg;
s1p_old = nomsg;
s1p_new = nomsg;
s2p_old = nomsg;
s2p_new = nomsg;
i2 = 0;
while (i2 < 10) {
{
Console_task_each_pals_period();
Side1_activestandby_task_each_pals_period();
Side2_activestandby_task_each_pals_period();
Pendulum_prism_task_each_pals_period();
cs1_old = cs1_new;
cs1_new = nomsg;
cs2_old = cs2_new;
cs2_new = nomsg;
s1s2_old = s1s2_new;
s1s2_new = nomsg;
s1s1_old = s1s1_new;
s1s1_new = nomsg;
s2s1_old = s2s1_new;
s2s1_new = nomsg;
s2s2_old = s2s2_new;
s2s2_new = nomsg;
s1p_old = s1p_new;
s1p_new = nomsg;
s2p_old = s2p_new;
s2p_new = nomsg;
c1 = check();
assert(c1);
i2 ++;
}
}
}
return 0;
}
char *get_tag(char *tag , int tagbuf_len )
{ char *tag_val ;
char c ;
char term ;
int t ;
int tmp ;
int tmp___0 ;
int tmp___1 ;
int tmp___2 ;
int tmp___3 ;
int tmp___4 ;
int tmp___5 ;
int tmp___6 ;
int tmp___7 ;
int tmp___8 ;
int tmp___9 ;
int tmp___10 ;
int tmp___11 ;
int tmp___12 ;
int __cil_tmp21 ;
int __cil_tmp22 ;
int __cil_tmp23 ;
void *__cil_tmp24 ;
char *__cil_tmp25 ;
void *__cil_tmp26 ;
int __cil_tmp27 ;
char *__cil_tmp28 ;
char *__cil_tmp29 ;
int __cil_tmp30 ;
void *__cil_tmp31 ;
int __cil_tmp32 ;
int __cil_tmp33 ;
void *__cil_tmp34 ;
char *__cil_tmp35 ;
void *__cil_tmp36 ;
int __cil_tmp37 ;
int __cil_tmp38 ;
int __cil_tmp39 ;
int __cil_tmp40 ;
char *__cil_tmp41 ;
char *__cil_tmp42 ;
void *__cil_tmp43 ;
int __cil_tmp44 ;
int __cil_tmp45 ;
int __cil_tmp46 ;
char *__cil_tmp47 ;
char *__cil_tmp48 ;
{
#line 9
t = 0;
#line 11
tagbuf_len = tagbuf_len - 1;
{
#line 13
while (1) {
while_0_continue: /* CIL Label */ ;
{
#line 14
tmp = __VERIFIER_nondet_char();
#line 14
c = (char )tmp;
#line 13
tmp___0 = ap_isspace(c);
}
#line 13
if (tmp___0) {
} else {
goto while_0_break;
}
}
while_0_break: /* CIL Label */ ;
}
{
#line 17
__cil_tmp21 = (int )c;
#line 17
if (__cil_tmp21 == 45) {
{
#line 18
tmp___1 = __VERIFIER_nondet_char();
#line 18
c = (char )tmp___1;
}
{
#line 19
__cil_tmp22 = (int )c;
#line 19
if (__cil_tmp22 == 45) {
{
#line 20
while (1) {
while_1_continue: /* CIL Label */ ;
{
#line 21
tmp___2 = __VERIFIER_nondet_char();
#line 21
c = (char )tmp___2;
#line 20
tmp___3 = ap_isspace(c);
}
#line 20
if (tmp___3) {
} else {
goto while_1_break;
}
}
while_1_break: /* CIL Label */ ;
}
{
#line 23
__cil_tmp23 = (int )c;
#line 23
if (__cil_tmp23 == 62) {
{
#line 24
ap_cpystrn(tag, "done", tagbuf_len);
}
#line 25
return (tag);
} else {
}
}
} else {
}
}
{
#line 28
__cil_tmp24 = (void *)0;
#line 28
return ((char *)__cil_tmp24);
}
} else {
}
}
{
#line 31
while (1) {
while_2_continue: /* CIL Label */ ;
#line 32
if (t == tagbuf_len) {
#line 33
__cil_tmp25 = tag + t;
#line 33
*__cil_tmp25 = (char)0;
{
#line 34
__cil_tmp26 = (void *)0;
#line 34
return ((char *)__cil_tmp26);
}
} else {
}
{
#line 36
__cil_tmp27 = (int )c;
#line 36
if (__cil_tmp27 == 61) {
goto while_2_break;
} else {
{
#line 36
tmp___4 = ap_isspace(c);
}
#line 36
if (tmp___4) {
goto while_2_break;
} else {
}
}
}
{
#line 39
tmp___5 = ap_tolower(c);
#line 39
__cil_tmp28 = tag + t;
#line 39
*__cil_tmp28 = (char )tmp___5;
#line 40
t = t + 1;
#line 41
tmp___6 = __VERIFIER_nondet_char();
#line 41
c = (char )tmp___6;
}
}
while_2_break: /* CIL Label */ ;
}
#line 44
__cil_tmp29 = tag + t;
#line 44
*__cil_tmp29 = (char)0;
#line 45
t = t + 1;
#line 46
tag_val = tag + t;
{
#line 48
while (1) {
while_3_continue: /* CIL Label */ ;
{
#line 48
tmp___8 = ap_isspace(c);
}
#line 48
if (tmp___8) {
} else {
goto while_3_break;
}
{
#line 49
tmp___7 = __VERIFIER_nondet_char();
#line 49
c = (char )tmp___7;
}
}
while_3_break: /* CIL Label */ ;
}
{
#line 51
__cil_tmp30 = (int )c;
#line 51
if (__cil_tmp30 != 61) {
{
#line 52
__cil_tmp31 = (void *)0;
#line 52
return ((char *)__cil_tmp31);
}
} else {
}
}
{
#line 55
while (1) {
while_4_continue: /* CIL Label */ ;
{
#line 56
tmp___9 = __VERIFIER_nondet_char();
#line 56
c = (char )tmp___9;
#line 55
tmp___10 = ap_isspace(c);
}
#line 55
if (tmp___10) {
} else {
goto while_4_break;
}
}
while_4_break: /* CIL Label */ ;
}
{
#line 59
__cil_tmp32 = (int )c;
#line 59
if (__cil_tmp32 != 34) {
{
#line 59
__cil_tmp33 = (int )c;
#line 59
if (__cil_tmp33 != 39) {
{
#line 60
__cil_tmp34 = (void *)0;
#line 60
return ((char *)__cil_tmp34);
}
} else {
}
}
} else {
}
}
#line 62
term = c;
{
#line 63
while (1) {
while_5_continue: /* CIL Label */ ;
{
#line 64
tmp___11 = __VERIFIER_nondet_char();
#line 64
c = (char )tmp___11;
}
#line 65
if (t == tagbuf_len) {
#line 66
__cil_tmp35 = tag + t;
#line 66
*__cil_tmp35 = (char)0;
{
#line 67
__cil_tmp36 = (void *)0;
#line 67
return ((char *)__cil_tmp36);
}
} else {
}
{
#line 70
__cil_tmp37 = (int )c;
#line 70
if (__cil_tmp37 == 92) {
{
#line 71
tmp___12 = __VERIFIER_nondet_char();
#line 71
c = (char )tmp___12;
}
{
#line 72
__cil_tmp38 = (int )term;
#line 72
__cil_tmp39 = (int )c;
#line 72
if (__cil_tmp39 != __cil_tmp38) {
{
#line 74
__cil_tmp40 = t + 1;
#line 74
if (__cil_tmp40 < tagbuf_len) {
} else {
{
#line 74
__assert_fail("t + 1 < tagbuf_len", "../versisec/apache/progs/apacheCVE-2004-0940get_tag_iter1_prefixLong_arr_ok.c",
74U, "get_tag");
}
}
}
#line 77
__cil_tmp41 = tag + t;
#line 77
*__cil_tmp41 = (char )'\\';
#line 78
t = t + 1;
#line 79
if (t == tagbuf_len) {
#line 81
__cil_tmp42 = tag + t;
#line 81
*__cil_tmp42 = (char)0;
{
#line 82
__cil_tmp43 = (void *)0;
#line 82
return ((char *)__cil_tmp43);
}
} else {
}
} else {
}
}
} else {
{
#line 86
__cil_tmp44 = (int )term;
#line 86
__cil_tmp45 = (int )c;
#line 86
if (__cil_tmp45 == __cil_tmp44) {
goto while_5_break;
} else {
}
}
}
}
{
#line 91
__cil_tmp46 = t + 2;
#line 91
if (__cil_tmp46 < tagbuf_len) {
} else {
{
#line 91
__assert_fail("t + 2 < tagbuf_len", "../versisec/apache/progs/apacheCVE-2004-0940get_tag_iter1_prefixLong_arr_ok.c",
91U, "get_tag");
}
}
}
#line 94
__cil_tmp47 = tag + t;
#line 94
*__cil_tmp47 = c;
#line 95
t = t + 1;
}
while_5_break: /* CIL Label */ ;
}
#line 99
__cil_tmp48 = tag + t;
#line 99
*__cil_tmp48 = (char)0;
#line 101
return (tag);
}
}
void main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
ep12 = __VERIFIER_nondet__Bool();
ep13 = __VERIFIER_nondet__Bool();
ep14 = __VERIFIER_nondet__Bool();
ep21 = __VERIFIER_nondet__Bool();
ep23 = __VERIFIER_nondet__Bool();
ep24 = __VERIFIER_nondet__Bool();
ep31 = __VERIFIER_nondet__Bool();
ep32 = __VERIFIER_nondet__Bool();
ep34 = __VERIFIER_nondet__Bool();
ep41 = __VERIFIER_nondet__Bool();
ep42 = __VERIFIER_nondet__Bool();
ep43 = __VERIFIER_nondet__Bool();
id1 = __VERIFIER_nondet_char();
r1 = __VERIFIER_nondet_char();
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_char();
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_char();
st3 = __VERIFIER_nondet_char();
nl3 = __VERIFIER_nondet_char();
m3 = __VERIFIER_nondet_char();
max3 = __VERIFIER_nondet_char();
mode3 = __VERIFIER_nondet__Bool();
newmax3 = __VERIFIER_nondet__Bool();
id4 = __VERIFIER_nondet_char();
r4 = __VERIFIER_nondet_char();
st4 = __VERIFIER_nondet_char();
nl4 = __VERIFIER_nondet_char();
m4 = __VERIFIER_nondet_char();
max4 = __VERIFIER_nondet_char();
mode4 = __VERIFIER_nondet__Bool();
newmax4 = __VERIFIER_nondet__Bool();
i2 = init();
__VERIFIER_assume(i2);
p12_old = nomsg;
p12_new = nomsg;
p13_old = nomsg;
p13_new = nomsg;
p14_old = nomsg;
p14_new = nomsg;
p21_old = nomsg;
p21_new = nomsg;
p23_old = nomsg;
p23_new = nomsg;
p24_old = nomsg;
p24_new = nomsg;
p31_old = nomsg;
p31_new = nomsg;
p32_old = nomsg;
p32_new = nomsg;
p34_old = nomsg;
p34_new = nomsg;
p41_old = nomsg;
p41_new = nomsg;
p42_old = nomsg;
p42_new = nomsg;
p43_old = nomsg;
p43_new = nomsg;
i2 = 0;
while (i2 < 8) {
{
node1();
node2();
node3();
node4();
p12_old = p12_new;
p12_new = nomsg;
p13_old = p13_new;
p13_new = nomsg;
p14_old = p14_new;
p14_new = nomsg;
p21_old = p21_new;
p21_new = nomsg;
p23_old = p23_new;
p23_new = nomsg;
p24_old = p24_new;
p24_new = nomsg;
p31_old = p31_new;
p31_new = nomsg;
p32_old = p32_new;
p32_new = nomsg;
p34_old = p34_new;
p34_new = nomsg;
p41_old = p41_new;
p41_new = nomsg;
p42_old = p42_new;
p42_new = nomsg;
p43_old = p43_new;
p43_new = nomsg;
c1 = check();
assert(c1);
i2 ++;
}
}
}
}
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_char();
st1 = __VERIFIER_nondet_char();
nl1 = __VERIFIER_nondet_char();
m1 = __VERIFIER_nondet_char();
max1 = __VERIFIER_nondet_char();
mode1 = __VERIFIER_nondet__Bool();
id2 = __VERIFIER_nondet_char();
r2 = __VERIFIER_nondet_char();
st2 = __VERIFIER_nondet_char();
nl2 = __VERIFIER_nondet_char();
m2 = __VERIFIER_nondet_char();
max2 = __VERIFIER_nondet_char();
mode2 = __VERIFIER_nondet__Bool();
id3 = __VERIFIER_nondet_char();
r3 = __VERIFIER_nondet_char();
st3 = __VERIFIER_nondet_char();
nl3 = __VERIFIER_nondet_char();
m3 = __VERIFIER_nondet_char();
max3 = __VERIFIER_nondet_char();
mode3 = __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;
}
int main(void)
{
int c1 ;
int i2 ;
{
c1 = 0;
r1 = __VERIFIER_nondet_char();
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();
id5 = __VERIFIER_nondet_char();
st5 = __VERIFIER_nondet_char();
send5 = __VERIFIER_nondet_char();
mode5 = __VERIFIER_nondet_bool();
alive5 = __VERIFIER_nondet_bool();
id6 = __VERIFIER_nondet_char();
st6 = __VERIFIER_nondet_char();
send6 = __VERIFIER_nondet_char();
mode6 = __VERIFIER_nondet_bool();
alive6 = __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;
p5_old = nomsg;
p5_new = nomsg;
p6_old = nomsg;
p6_new = nomsg;
i2 = 0;
while (i2 < 12) {
{
node1();
node2();
node3();
node4();
node5();
node6();
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;
p5_old = p5_new;
p5_new = nomsg;
p6_old = p6_new;
p6_new = nomsg;
c1 = check();
assert(c1);
i2 ++;
}
}
}
return 0;
}