BDD bits_range_bdd(uint32_t low_bits,uint32_t high_bits) {
BDD rval,tail,newbdd;
int i;
uint32_t b;
if (low_bits>0) {
tail=bddtrue;
for (i=31,b=1;i>=0;i--,b<<=1) {
if (low_bits&b)
newbdd=bdd_addref(bdd_and(bdd_ithvar(i),tail));
else
newbdd=bdd_addref(bdd_or(bdd_ithvar(i),tail));
bdd_delref(tail);
tail=newbdd;
}
rval=tail;
} else
rval=bddtrue;
if (high_bits<UINT32_MAX) {
tail=bddtrue;
for (i=31,b=1;i>=0;i--,b<<=1) {
if (high_bits&b)
newbdd=bdd_addref(bdd_or(bdd_nithvar(i),tail));
else
newbdd=bdd_addref(bdd_and(bdd_nithvar(i),tail));
bdd_delref(tail);
tail=newbdd;
}
rval=bdd_addref(bdd_and(rval,tail));
bdd_delref(tail);
}
return rval;
}
static bddp hit_z2b_rec(zddp f, my_hash *h)
{
if(f == zdd_top()) return bdd_bot();
if(f == zdd_bot()) return bdd_top();
bddp r;
if(ht_search((uintptr_t)f, (uintptr_t*)&r, h)) return r;
INC_RECDEPTH(recdepth);
bddp r0 = hit_z2b_rec(zdd_lo(f), h);
bddp r1 = hit_z2b_rec(zdd_hi(f), h);
DEC_RECDEPTH(recdepth);
bddp t = bdd_node(zdd_itemval(f), r1, bdd_top());
ENSURE_TRUE_MSG(t != BDD_NULL, "BDD operation failed");
r = bdd_and(r0, t);
ENSURE_TRUE_MSG(r != BDD_NULL, "BDD operation failed");
ht_insert((uintptr_t)f, (uintptr_t)r, h);
#ifdef SIZE_LOG
const uintmax_t insize = zdd_size(f);
const uintmax_t outsize = bdd_size(r);
fprintf(sizelog, "%ju\t%ju\n", insize, outsize);
if(maxsize < outsize) maxsize = outsize;
#endif /*SIZE_LOG*/
return r;
}
double support(TransitionSystem *model, BDD result) {
int count = 0;
State *pi = model->pseudo_initial;
State *child;
int reals = 0;
for(int i = 0; i < pi->children_size; i++) {
child = pi->children[i];
if (child == NULL)
continue;
BDD tt = bdd_addref(bdd_and(result, model->states_bdds[child->id]));
if (tt == model->states_bdds[child->id])
count += child->cardinality;
bdd_delref(tt);
reals += child->cardinality;
}
printf("%d\t%d\t", count, reals - count);
return (double)count / reals;
}
void set_range_width(uint32_t low_code,uint32_t high_code,int width) {
BDD x,y;
/* sanity check */
if (low_code>high_code)
return;
/* make a BDD for the range */
x=code_range_bdd(low_code,high_code);
/* if (in range) /\ (already defined) === true, we've been pre-empted */
y=bdd_and(x,defined_codes); /* note no addref, we don't need it */
if (y==x) {
bdd_delref(x);
return;
}
/* if (in range) /\ (already defined) !== false, must split */
if (y!=bddfalse) {
bdd_delref(x);
set_range_width(low_code,(low_code+high_code)/2,width);
set_range_width((low_code+high_code)/2+1,high_code,width);
return;
}
y=bdd_addref(bdd_or(x,defined_codes));
bdd_delref(defined_codes);
defined_codes=y;
if (width==0) {
y=bdd_addref(bdd_or(x,zero_codes));
bdd_delref(zero_codes);
zero_codes=y;
} else if (width==2) {
y=bdd_addref(bdd_or(x,wide_codes));
bdd_delref(wide_codes);
wide_codes=y;
}
bdd_delref(x);
}
int main() {
bdd_init(1000000,1000000,40);
bdd_ptr v1 = ithvar(0);
bdd_ptr v4 = ithvar(1);
bdd_ptr v8 = ithvar(2);
bdd_ptr v11 = ithvar(3);
bdd_ptr v14 = ithvar(4);
bdd_ptr v17 = ithvar(5);
bdd_ptr v21 = ithvar(6);
bdd_ptr v24 = ithvar(7);
bdd_ptr v27 = ithvar(8);
bdd_ptr v30 = ithvar(9);
bdd_ptr v34 = ithvar(10);
bdd_ptr v37 = ithvar(11);
bdd_ptr v40 = ithvar(12);
bdd_ptr v43 = ithvar(13);
bdd_ptr v47 = ithvar(14);
bdd_ptr v50 = ithvar(15);
bdd_ptr v53 = ithvar(16);
bdd_ptr v56 = ithvar(17);
bdd_ptr v60 = ithvar(18);
bdd_ptr v63 = ithvar(19);
bdd_ptr v66 = ithvar(20);
bdd_ptr v69 = ithvar(21);
bdd_ptr v73 = ithvar(22);
bdd_ptr v76 = ithvar(23);
bdd_ptr v79 = ithvar(24);
bdd_ptr v82 = ithvar(25);
bdd_ptr v86 = ithvar(26);
bdd_ptr v89 = ithvar(27);
bdd_ptr v92 = ithvar(28);
bdd_ptr v95 = ithvar(29);
bdd_ptr v99 = ithvar(30);
bdd_ptr v102 = ithvar(31);
bdd_ptr v105 = ithvar(32);
bdd_ptr v108 = ithvar(33);
bdd_ptr v112 = ithvar(34);
bdd_ptr v115 = ithvar(35);
std::cout << 0 << std::endl;
bdd_ptr v118 = bdd_not(v1);
std::cout << 1 << std::endl;
bdd_ptr v119 = bdd_not(v4);
std::cout << 2 << std::endl;
bdd_ptr v122 = bdd_not(v11);
std::cout << 3 << std::endl;
bdd_ptr v123 = bdd_not(v17);
std::cout << 4 << std::endl;
bdd_ptr v126 = bdd_not(v24);
std::cout << 5 << std::endl;
bdd_ptr v127 = bdd_not(v30);
std::cout << 6 << std::endl;
bdd_ptr v130 = bdd_not(v37);
std::cout << 7 << std::endl;
bdd_ptr v131 = bdd_not(v43);
std::cout << 8 << std::endl;
bdd_ptr v134 = bdd_not(v50);
std::cout << 9 << std::endl;
bdd_ptr v135 = bdd_not(v56);
std::cout << 10 << std::endl;
bdd_ptr v138 = bdd_not(v63);
std::cout << 11 << std::endl;
bdd_ptr v139 = bdd_not(v69);
std::cout << 12 << std::endl;
bdd_ptr v142 = bdd_not(v76);
std::cout << 13 << std::endl;
bdd_ptr v143 = bdd_not(v82);
std::cout << 14 << std::endl;
bdd_ptr v146 = bdd_not(v89);
std::cout << 15 << std::endl;
bdd_ptr v147 = bdd_not(v95);
std::cout << 16 << std::endl;
bdd_ptr v150 = bdd_not(v102);
std::cout << 17 << std::endl;
bdd_ptr v151 = bdd_not(v108);
std::cout << 18 << std::endl;
bdd_ptr v154 = bdd_nand(v118,v4);
std::cout << 19 << std::endl;
bdd_ptr v157 = bdd_nor(v8,v119);
std::cout << 20 << std::endl;
bdd_ptr v158 = bdd_nor(v14,v119);
std::cout << 21 << std::endl;
bdd_ptr v159 = bdd_nand(v122,v17);
std::cout << 22 << std::endl;
bdd_ptr v162 = bdd_nand(v126,v30);
std::cout << 23 << std::endl;
bdd_ptr v165 = bdd_nand(v130,v43);
std::cout << 24 << std::endl;
bdd_ptr v168 = bdd_nand(v134,v56);
std::cout << 25 << std::endl;
bdd_ptr v171 = bdd_nand(v138,v69);
std::cout << 26 << std::endl;
bdd_ptr v174 = bdd_nand(v142,v82);
std::cout << 27 << std::endl;
bdd_ptr v177 = bdd_nand(v146,v95);
std::cout << 28 << std::endl;
bdd_ptr v180 = bdd_nand(v150,v108);
std::cout << 29 << std::endl;
bdd_ptr v183 = bdd_nor(v21,v123);
std::cout << 30 << std::endl;
bdd_ptr v184 = bdd_nor(v27,v123);
std::cout << 31 << std::endl;
bdd_ptr v185 = bdd_nor(v34,v127);
std::cout << 32 << std::endl;
bdd_ptr v186 = bdd_nor(v40,v127);
std::cout << 33 << std::endl;
bdd_ptr v187 = bdd_nor(v47,v131);
std::cout << 34 << std::endl;
bdd_ptr v188 = bdd_nor(v53,v131);
std::cout << 35 << std::endl;
bdd_ptr v189 = bdd_nor(v60,v135);
std::cout << 36 << std::endl;
bdd_ptr v190 = bdd_nor(v66,v135);
std::cout << 37 << std::endl;
bdd_ptr v191 = bdd_nor(v73,v139);
std::cout << 38 << std::endl;
bdd_ptr v192 = bdd_nor(v79,v139);
std::cout << 39 << std::endl;
bdd_ptr v193 = bdd_nor(v86,v143);
std::cout << 40 << std::endl;
bdd_ptr v194 = bdd_nor(v92,v143);
std::cout << 41 << std::endl;
bdd_ptr v195 = bdd_nor(v99,v147);
std::cout << 42 << std::endl;
bdd_ptr v196 = bdd_nor(v105,v147);
std::cout << 43 << std::endl;
bdd_ptr v197 = bdd_nor(v112,v151);
std::cout << 44 << std::endl;
bdd_ptr v198 = bdd_nor(v115,v151);
std::cout << 45 << std::endl;
bdd_ptr v199_1_0 = bdd_and(v154,v159);
bdd_ptr v199_1_2 = bdd_and(v162,v165);
bdd_ptr v199_1_4 = bdd_and(v168,v171);
bdd_ptr v199_1_6 = bdd_and(v174,v177);
bdd_ptr v199_2_0 = bdd_and(v199_1_0,v199_1_2);
bdd_ptr v199_2_4 = bdd_and(v199_1_4,v199_1_6);
bdd_ptr v199_3_0 = bdd_and(v199_2_0,v199_2_4);
bdd_ptr v199 = bdd_and(v199_3_0,v180);
std::cout << 46 << std::endl;
bdd_ptr v203 = bdd_not(v199);
std::cout << 47 << std::endl;
bdd_ptr v213 = bdd_not(v199);
std::cout << 48 << std::endl;
bdd_ptr v223 = bdd_not(v199);
std::cout << 49 << std::endl;
bdd_ptr v224 = bdd_xor(v203,v154);
std::cout << 50 << std::endl;
bdd_ptr v227 = bdd_xor(v203,v159);
std::cout << 51 << std::endl;
bdd_ptr v230 = bdd_xor(v203,v162);
std::cout << 52 << std::endl;
bdd_ptr v233 = bdd_xor(v203,v165);
std::cout << 53 << std::endl;
bdd_ptr v236 = bdd_xor(v203,v168);
std::cout << 54 << std::endl;
bdd_ptr v239 = bdd_xor(v203,v171);
std::cout << 55 << std::endl;
bdd_ptr v242 = bdd_nand(v1,v213);
std::cout << 56 << std::endl;
bdd_ptr v243 = bdd_xor(v203,v174);
std::cout << 57 << std::endl;
bdd_ptr v246 = bdd_nand(v213,v11);
std::cout << 58 << std::endl;
bdd_ptr v247 = bdd_xor(v203,v177);
std::cout << 59 << std::endl;
bdd_ptr v250 = bdd_nand(v213,v24);
std::cout << 60 << std::endl;
bdd_ptr v251 = bdd_xor(v203,v180);
std::cout << 61 << std::endl;
bdd_ptr v254 = bdd_nand(v213,v37);
std::cout << 62 << std::endl;
bdd_ptr v255 = bdd_nand(v213,v50);
std::cout << 63 << std::endl;
bdd_ptr v256 = bdd_nand(v213,v63);
std::cout << 64 << std::endl;
bdd_ptr v257 = bdd_nand(v213,v76);
std::cout << 65 << std::endl;
bdd_ptr v258 = bdd_nand(v213,v89);
std::cout << 66 << std::endl;
bdd_ptr v259 = bdd_nand(v213,v102);
std::cout << 67 << std::endl;
bdd_ptr v260 = bdd_nand(v224,v157);
std::cout << 68 << std::endl;
bdd_ptr v263 = bdd_nand(v224,v158);
std::cout << 69 << std::endl;
bdd_ptr v264 = bdd_nand(v227,v183);
std::cout << 70 << std::endl;
bdd_ptr v267 = bdd_nand(v230,v185);
std::cout << 71 << std::endl;
bdd_ptr v270 = bdd_nand(v233,v187);
std::cout << 72 << std::endl;
bdd_ptr v273 = bdd_nand(v236,v189);
std::cout << 73 << std::endl;
bdd_ptr v276 = bdd_nand(v239,v191);
std::cout << 74 << std::endl;
bdd_ptr v279 = bdd_nand(v243,v193);
std::cout << 75 << std::endl;
bdd_ptr v282 = bdd_nand(v247,v195);
std::cout << 76 << std::endl;
bdd_ptr v285 = bdd_nand(v251,v197);
std::cout << 77 << std::endl;
bdd_ptr v288 = bdd_nand(v227,v184);
std::cout << 78 << std::endl;
bdd_ptr v289 = bdd_nand(v230,v186);
std::cout << 79 << std::endl;
bdd_ptr v290 = bdd_nand(v233,v188);
std::cout << 80 << std::endl;
bdd_ptr v291 = bdd_nand(v236,v190);
std::cout << 81 << std::endl;
bdd_ptr v292 = bdd_nand(v239,v192);
std::cout << 82 << std::endl;
bdd_ptr v293 = bdd_nand(v243,v194);
std::cout << 83 << std::endl;
bdd_ptr v294 = bdd_nand(v247,v196);
std::cout << 84 << std::endl;
bdd_ptr v295 = bdd_nand(v251,v198);
std::cout << 85 << std::endl;
bdd_ptr v296_1_0 = bdd_and(v260,v264);
bdd_ptr v296_1_2 = bdd_and(v267,v270);
bdd_ptr v296_1_4 = bdd_and(v273,v276);
bdd_ptr v296_1_6 = bdd_and(v279,v282);
bdd_ptr v296_2_0 = bdd_and(v296_1_0,v296_1_2);
bdd_ptr v296_2_4 = bdd_and(v296_1_4,v296_1_6);
bdd_ptr v296_3_0 = bdd_and(v296_2_0,v296_2_4);
bdd_ptr v296 = bdd_and(v296_3_0,v285);
std::cout << 86 << std::endl;
bdd_ptr v300 = bdd_not(v263);
std::cout << 87 << std::endl;
bdd_ptr v301 = bdd_not(v288);
std::cout << 88 << std::endl;
bdd_ptr v302 = bdd_not(v289);
std::cout << 89 << std::endl;
bdd_ptr v303 = bdd_not(v290);
std::cout << 90 << std::endl;
bdd_ptr v304 = bdd_not(v291);
std::cout << 91 << std::endl;
bdd_ptr v305 = bdd_not(v292);
std::cout << 92 << std::endl;
bdd_ptr v306 = bdd_not(v293);
std::cout << 93 << std::endl;
bdd_ptr v307 = bdd_not(v294);
std::cout << 94 << std::endl;
bdd_ptr v308 = bdd_not(v295);
std::cout << 95 << std::endl;
bdd_ptr v309 = bdd_not(v296);
std::cout << 96 << std::endl;
bdd_ptr v319 = bdd_not(v296);
std::cout << 97 << std::endl;
bdd_ptr v329 = bdd_not(v296);
std::cout << 98 << std::endl;
bdd_ptr v330 = bdd_xor(v309,v260);
std::cout << 99 << std::endl;
bdd_ptr v331 = bdd_xor(v309,v264);
std::cout << 100 << std::endl;
bdd_ptr v332 = bdd_xor(v309,v267);
std::cout << 101 << std::endl;
bdd_ptr v333 = bdd_xor(v309,v270);
std::cout << 102 << std::endl;
bdd_ptr v334 = bdd_nand(v8,v319);
std::cout << 103 << std::endl;
bdd_ptr v335 = bdd_xor(v309,v273);
std::cout << 104 << std::endl;
bdd_ptr v336 = bdd_nand(v319,v21);
std::cout << 105 << std::endl;
bdd_ptr v337 = bdd_xor(v309,v276);
std::cout << 106 << std::endl;
bdd_ptr v338 = bdd_nand(v319,v34);
std::cout << 107 << std::endl;
bdd_ptr v339 = bdd_xor(v309,v279);
std::cout << 108 << std::endl;
bdd_ptr v340 = bdd_nand(v319,v47);
std::cout << 109 << std::endl;
bdd_ptr v341 = bdd_xor(v309,v282);
std::cout << 110 << std::endl;
bdd_ptr v342 = bdd_nand(v319,v60);
std::cout << 111 << std::endl;
bdd_ptr v343 = bdd_xor(v309,v285);
std::cout << 112 << std::endl;
bdd_ptr v344 = bdd_nand(v319,v73);
std::cout << 113 << std::endl;
bdd_ptr v345 = bdd_nand(v319,v86);
std::cout << 114 << std::endl;
bdd_ptr v346 = bdd_nand(v319,v99);
std::cout << 115 << std::endl;
bdd_ptr v347 = bdd_nand(v319,v112);
std::cout << 116 << std::endl;
bdd_ptr v348 = bdd_nand(v330,v300);
std::cout << 117 << std::endl;
bdd_ptr v349 = bdd_nand(v331,v301);
std::cout << 118 << std::endl;
bdd_ptr v350 = bdd_nand(v332,v302);
std::cout << 119 << std::endl;
bdd_ptr v351 = bdd_nand(v333,v303);
std::cout << 120 << std::endl;
bdd_ptr v352 = bdd_nand(v335,v304);
std::cout << 121 << std::endl;
bdd_ptr v353 = bdd_nand(v337,v305);
std::cout << 122 << std::endl;
bdd_ptr v354 = bdd_nand(v339,v306);
std::cout << 123 << std::endl;
bdd_ptr v355 = bdd_nand(v341,v307);
std::cout << 124 << std::endl;
bdd_ptr v356 = bdd_nand(v343,v308);
std::cout << 125 << std::endl;
bdd_ptr v357_1_0 = bdd_and(v348,v349);
bdd_ptr v357_1_2 = bdd_and(v350,v351);
bdd_ptr v357_1_4 = bdd_and(v352,v353);
bdd_ptr v357_1_6 = bdd_and(v354,v355);
bdd_ptr v357_2_0 = bdd_and(v357_1_0,v357_1_2);
bdd_ptr v357_2_4 = bdd_and(v357_1_4,v357_1_6);
bdd_ptr v357_3_0 = bdd_and(v357_2_0,v357_2_4);
bdd_ptr v357 = bdd_and(v357_3_0,v356);
std::cout << 126 << std::endl;
bdd_ptr v360 = bdd_not(v357);
std::cout << 127 << std::endl;
bdd_ptr v370 = bdd_not(v357);
std::cout << 128 << std::endl;
bdd_ptr v371 = bdd_nand(v14,v360);
std::cout << 129 << std::endl;
bdd_ptr v372 = bdd_nand(v360,v27);
std::cout << 130 << std::endl;
bdd_ptr v373 = bdd_nand(v360,v40);
std::cout << 131 << std::endl;
bdd_ptr v374 = bdd_nand(v360,v53);
std::cout << 132 << std::endl;
bdd_ptr v375 = bdd_nand(v360,v66);
std::cout << 133 << std::endl;
bdd_ptr v376 = bdd_nand(v360,v79);
std::cout << 134 << std::endl;
bdd_ptr v377 = bdd_nand(v360,v92);
std::cout << 135 << std::endl;
bdd_ptr v378 = bdd_nand(v360,v105);
std::cout << 136 << std::endl;
bdd_ptr v379 = bdd_nand(v360,v115);
std::cout << 137 << std::endl;
bdd_ptr v380_1_0 = bdd_nand(v4,v242);
bdd_ptr v380_1_2 = bdd_nand(v334,v371);
bdd_ptr v380 = bdd_nand(v380_1_0,v380_1_2);
std::cout << 138 << std::endl;
bdd_ptr v381_1_0 = bdd_nand(v246,v336);
bdd_ptr v381_1_2 = bdd_nand(v372,v17);
bdd_ptr v381 = bdd_nand(v381_1_0,v381_1_2);
std::cout << 139 << std::endl;
bdd_ptr v386_1_0 = bdd_nand(v250,v338);
bdd_ptr v386_1_2 = bdd_nand(v373,v30);
bdd_ptr v386 = bdd_nand(v386_1_0,v386_1_2);
std::cout << 140 << std::endl;
bdd_ptr v393_1_0 = bdd_nand(v254,v340);
bdd_ptr v393_1_2 = bdd_nand(v374,v43);
bdd_ptr v393 = bdd_nand(v393_1_0,v393_1_2);
std::cout << 141 << std::endl;
bdd_ptr v399_1_0 = bdd_nand(v255,v342);
bdd_ptr v399_1_2 = bdd_nand(v375,v56);
bdd_ptr v399 = bdd_nand(v399_1_0,v399_1_2);
std::cout << 142 << std::endl;
bdd_ptr v404_1_0 = bdd_nand(v256,v344);
bdd_ptr v404_1_2 = bdd_nand(v376,v69);
bdd_ptr v404 = bdd_nand(v404_1_0,v404_1_2);
std::cout << 143 << std::endl;
bdd_ptr v407_1_0 = bdd_nand(v257,v345);
bdd_ptr v407_1_2 = bdd_nand(v377,v82);
bdd_ptr v407 = bdd_nand(v407_1_0,v407_1_2);
std::cout << 144 << std::endl;
bdd_ptr v411_1_0 = bdd_nand(v258,v346);
bdd_ptr v411_1_2 = bdd_nand(v378,v95);
bdd_ptr v411 = bdd_nand(v411_1_0,v411_1_2);
std::cout << 145 << std::endl;
bdd_ptr v414_1_0 = bdd_nand(v259,v347);
bdd_ptr v414_1_2 = bdd_nand(v379,v108);
bdd_ptr v414 = bdd_nand(v414_1_0,v414_1_2);
std::cout << 146 << std::endl;
bdd_ptr v415 = bdd_not(v380);
std::cout << 147 << std::endl;
bdd_ptr v416_1_0 = bdd_and(v381,v386);
bdd_ptr v416_1_2 = bdd_and(v393,v399);
bdd_ptr v416_1_4 = bdd_and(v404,v407);
bdd_ptr v416_1_6 = bdd_and(v411,v414);
bdd_ptr v416_2_0 = bdd_and(v416_1_0,v416_1_2);
bdd_ptr v416_2_4 = bdd_and(v416_1_4,v416_1_6);
bdd_ptr v416 = bdd_and(v416_2_0,v416_2_4);
std::cout << 148 << std::endl;
bdd_ptr v417 = bdd_not(v393);
std::cout << 149 << std::endl;
bdd_ptr v418 = bdd_not(v404);
std::cout << 150 << std::endl;
bdd_ptr v419 = bdd_not(v407);
std::cout << 151 << std::endl;
bdd_ptr v420 = bdd_not(v411);
std::cout << 152 << std::endl;
bdd_ptr v421 = bdd_nor(v415,v416);
std::cout << 153 << std::endl;
bdd_ptr v422 = bdd_nand(v386,v417);
std::cout << 154 << std::endl;
bdd_ptr v425_1_0 = bdd_nand(v386,v393);
bdd_ptr v425_1_2 = bdd_nand(v418,v399);
bdd_ptr v425 = bdd_nand(v425_1_0,v425_1_2);
std::cout << 155 << std::endl;
bdd_ptr v428_1_0 = bdd_nand(v399,v393);
bdd_ptr v428 = bdd_nand(v428_1_0,v419);
std::cout << 156 << std::endl;
bdd_ptr v429_1_0 = bdd_nand(v386,v393);
bdd_ptr v429_1_2 = bdd_nand(v407,v420);
bdd_ptr v429 = bdd_nand(v429_1_0,v429_1_2);
std::cout << 157 << std::endl;
bdd_ptr v430_1_0 = bdd_nand(v381,v386);
bdd_ptr v430_1_2 = bdd_nand(v422,v399);
bdd_ptr v430 = bdd_nand(v430_1_0,v430_1_2);
std::cout << 158 << std::endl;
bdd_ptr v431_1_0 = bdd_nand(v381,v386);
bdd_ptr v431_1_2 = bdd_nand(v425,v428);
bdd_ptr v431 = bdd_nand(v431_1_0,v431_1_2);
std::cout << 159 << std::endl;
bdd_ptr v432_1_0 = bdd_nand(v381,v422);
bdd_ptr v432_1_2 = bdd_nand(v425,v429);
bdd_ptr v432 = bdd_nand(v432_1_0,v432_1_2);
return 0;
}
/**Function********************************************************************
Synopsis [Generates a complete trace]
Description [This function is a private service of
bdd_partial_trace_executor_execute]
SideEffects [None]
******************************************************************************/
static Trace_ptr
bdd_partial_trace_executor_generate(const BDDPartialTraceExecutor_ptr self,
const BddStates goal_states,
node_ptr reachable, int length,
const NodeList_ptr language,
const char* trace_name)
{
Trace_ptr res;
DdManager* dd;
node_ptr path;
bdd_ptr target;
NODE_LIST_CHECK_INSTANCE(language);
dd = BddEnc_get_dd_manager(self->enc);
target = BddEnc_pick_one_state_rand(self->enc, goal_states);
path = cons((node_ptr) target, Nil);
if (Nil != reachable) {
reachable = cdr(reachable);
while (0 != length) {
bdd_ptr source;
bdd_ptr input;
bdd_ptr inputs;
bdd_ptr bwd_image;
bdd_ptr intersect;
/* pick source state */
bwd_image = BddFsm_get_backward_image(self->fsm, target);
intersect = bdd_and(dd, bwd_image, (bdd_ptr) car(reachable));
nusmv_assert(!bdd_is_false(dd, intersect));
source = BddEnc_pick_one_state(self->enc, intersect);
bdd_free(dd, intersect);
bdd_free(dd, bwd_image);
/* pick one input s.t. source -> (input) -> target */
inputs = BddFsm_states_to_states_get_inputs(self->fsm, source, target);
input = BddEnc_pick_one_input(self->enc, inputs);
nusmv_assert(!bdd_is_false(dd, input));
bdd_free(dd, inputs);
/* prepend input and source state */
path = cons((node_ptr) input, path);
path = cons((node_ptr) source, path);
-- length;
target = source;
reachable = cdr(reachable);
}
}
/* make sure the trace length is correct */
nusmv_assert(0 == length && Nil == reachable);
res = \
Mc_create_trace_from_bdd_state_input_list(self->enc, language, trace_name,
TRACE_TYPE_EXECUTION, path);
/* cleanup */
walk_dd(dd, bdd_free, path);
free_list(path);
return res;
}
/**Function********************************************************************
Synopsis [Executes a trace on the fsm given at construction time
using BDDs]
Description [The trace is executed using BDDs, that is a proof that
the fsm is compatible with the trace is built (if such proof
exists). Incomplete traces are filled-in with compatible values for
state and input variables.
Given trace can be either complete or incomplete.
The number of performed steps (transitions) is returned in *n_steps,
if a non-NULL pointer is given. If the initial state is not
compatible -1 is written.]
SideEffects [None]
SeeAlso []
******************************************************************************/
static Trace_ptr
bdd_partial_trace_executor_execute
(const PartialTraceExecutor_ptr partial_executor, const Trace_ptr trace,
const NodeList_ptr language, int* n_steps)
{
/* local references to self */
const BDDPartialTraceExecutor_ptr self = \
BDD_PARTIAL_TRACE_EXECUTOR(partial_executor);
const BaseTraceExecutor_ptr executor = \
BASE_TRACE_EXECUTOR(partial_executor);
Trace_ptr res = TRACE(NULL); /* failure */
int count = -1;
boolean success = true;
DdManager* dd;
BddStates trace_states;
TraceIter step = TRACE_END_ITER;
BddStates fwd_image = (BddStates) NULL;
node_ptr path = Nil; /* forward constrained images will be used
later to compute the complete trace */
const char* trace_description = "BDD Execution";
/* 0- Check prerequisites */
BDD_PARTIAL_TRACE_EXECUTOR_CHECK_INSTANCE(self);
TRACE_CHECK_INSTANCE(trace);
BDD_FSM_CHECK_INSTANCE(self->fsm);
BDD_ENC_CHECK_INSTANCE(self->enc);
dd = BddEnc_get_dd_manager(self->enc);
step = trace_first_iter(trace);
nusmv_assert(TRACE_END_ITER != step);
trace_states = TraceUtils_fetch_as_bdd(trace, step,
TRACE_ITER_SF_SYMBOLS, self->enc);
/* 1- Check Start State */
{
bdd_ptr init_bdd = BddFsm_get_init(self->fsm);
bdd_ptr invar_bdd = BddFsm_get_state_constraints(self->fsm);
BddStates source_states; /* last known states */
source_states = bdd_and(dd, init_bdd, invar_bdd);
bdd_and_accumulate(dd, &source_states, trace_states);
bdd_free(dd, invar_bdd);
bdd_free(dd, init_bdd);
bdd_free(dd, trace_states);
if (!bdd_is_false(dd, source_states)) {
boolean terminate = false;
path = cons(NODE_PTR(bdd_dup(source_states)), Nil);
++ count;
/* 2- Check Consecutive States are related by transition relation */
do {
BddStates last_state; /* (unshifted) next state */
BddStates next_state; /* next state constraints */
BddInputs next_input; /* next input constraints */
BddStatesInputsNexts next_combo; /* state-input-next constraints */
BddStatesInputsNexts constraints;
step = TraceIter_get_next(step);
if (TRACE_END_ITER != step) {
next_input = \
TraceUtils_fetch_as_bdd(trace, step, TRACE_ITER_I_SYMBOLS,
self->enc);
next_combo = \
TraceUtils_fetch_as_bdd(trace, step, TRACE_ITER_COMBINATORIAL,
self->enc);
last_state = \
TraceUtils_fetch_as_bdd(trace, step, TRACE_ITER_SF_SYMBOLS,
self->enc);
next_state = BddEnc_state_var_to_next_state_var(self->enc, last_state);
if (0 < BaseTraceExecutor_get_verbosity(executor)) {
fprintf(BaseTraceExecutor_get_output_stream(executor),
"-- executing step %d ... ", 1 + count);
fflush(BaseTraceExecutor_get_output_stream(executor));
}
/* building constrained fwd image */
constraints = bdd_and(dd, next_input, next_combo);
bdd_and_accumulate(dd, &constraints, next_state);
fwd_image =
BddFsm_get_sins_constrained_forward_image(self->fsm, source_states,
constraints);
/* test whether the constrained fwd image is not empty */
if (!bdd_is_false(dd, fwd_image)) {
if (0 < BaseTraceExecutor_get_verbosity(executor)) {
fprintf(BaseTraceExecutor_get_output_stream(executor), "done\n");
}
path = cons(NODE_PTR(fwd_image), path);
++ count;
}
else {
if (0 < BaseTraceExecutor_get_verbosity(executor)) {
fprintf(BaseTraceExecutor_get_output_stream(executor),
"failed!\n");
}
terminate = true;
success = false;
}
/* no longer used bdd refs */
bdd_free(dd, next_input);
bdd_free(dd, next_combo);
bdd_free(dd, last_state);
bdd_free(dd, next_state);
bdd_free(dd, source_states);
source_states = bdd_dup(fwd_image);
}
else {
if (0 == count) {
fprintf(BaseTraceExecutor_get_error_stream(executor),
"Warning: trace has no transitions.\n");
}
terminate = true;
}
} while (!terminate); /* loop on state/input pairs */
} /* if has initial state */
else {
fprintf(BaseTraceExecutor_get_error_stream(executor),
"Error: starting state is not initial state.\n");
success = false;
}
/* 3- If last state could be reached a complete trace exists */
if (success) {
if (0 < count) {
res = \
bdd_partial_trace_executor_generate(self, fwd_image, path,
count, language,
trace_description);
}
else { /* generates a complete state of trace of length 0 */
res = \
bdd_partial_trace_executor_generate(self, source_states,
Nil, 0, language,
trace_description);
}
nusmv_assert(TRACE(NULL) != res);
/* cleanup */
walk_dd(dd, bdd_free, path);
free_list(path);
}
bdd_free(dd, source_states);
}
/* as a final stage, verify loopbacks consistency using internal
service. The incomplete trace is compatible (that is, a valid
completion exists) iff exactly len(Trace) steps have been
performed *and* loopback data for the incomplete trace applies to
the complete one as well. */
if (TRACE(NULL) != res) {
if (Trace_get_length(trace) == count &&
partial_trace_executor_check_loopbacks(partial_executor, trace, res)) {
fprintf(BaseTraceExecutor_get_output_stream(executor),
"-- Trace was successfully completed.\n");
}
else {
Trace_destroy(res);
res = TRACE(NULL);
}
}
if (TRACE(NULL) == res) {
fprintf(BaseTraceExecutor_get_output_stream(executor),
"-- Trace could not be completed.\n");
}
if (NIL(int) != n_steps) { *n_steps = count; }
return res;
}
int Compass_write_sigref(NuSMVEnv_ptr env,
BddFsm_ptr fsm,
FILE* sigref_file,
FILE* prob_file, /* can be NULL */
FILE* ap_file, /* can be NULL */
Expr_ptr tau, /* can be NULL */
boolean do_indent /* Beautify the XML output */
)
{
BddEnc_ptr enc = BddFsm_get_bdd_encoding(fsm);
DDMgr_ptr dd = BddEnc_get_dd_manager(enc);
const NodeMgr_ptr nodemgr =
NODE_MGR(NuSMVEnv_get_value(env, ENV_NODE_MGR));
const TypeChecker_ptr tc = BaseEnc_get_type_checker(BASE_ENC(enc));
NodeList_ptr ap_list_add = NODE_LIST(NULL);
NodeList_ptr probs_list = NULL;
NodeList_ptr ap_list = NULL;
int retval = 0;
add_ptr prob_add;
add_ptr init_add;
add_ptr trans_add;
add_ptr tau_add;
bdd_ptr bdd_trans;
bdd_ptr state_mask = NULL;
bdd_ptr input_mask = NULL;
bdd_ptr next_state_mask = NULL;
bdd_ptr next_and_curr_state_mask = NULL;
/* preprocessing of the parameters */
/* tau */
if (EXPR(NULL) != tau) {
tau = Compile_FlattenSexp(BaseEnc_get_symb_table(BASE_ENC(enc)),
car(tau) /* gets rid of SIMPWFF */,
Nil);
}
/* prob_file */
if (NULL != prob_file) {
ParserProb_ptr pl_parser = NULL;
pl_parser = ParserProb_create(env);
ParserProb_parse_from_file(pl_parser, prob_file);
probs_list = ParserProb_get_prob_list(pl_parser);
if (NODE_LIST(NULL) != probs_list) {
Compass_check_prob_list(tc, probs_list);
}
ParserProb_destroy(pl_parser);
}
/* ap_file */
if (NULL != ap_file) {
ParserAp_ptr ap_parser = NULL;
ap_parser = ParserAp_create(env);
ParserAp_parse_from_file(ap_parser, ap_file);
ap_list = ParserAp_get_ap_list(ap_parser);
if (NODE_LIST(NULL) != ap_list) {
Compass_check_ap_list(tc, ap_list);
}
ParserAp_destroy(ap_parser);
}
/* collects all required pieces */
state_mask = BddEnc_get_state_frozen_vars_mask_bdd(enc);
input_mask = BddEnc_get_input_vars_mask_bdd(enc);
next_state_mask = BddEnc_state_var_to_next_state_var(enc, state_mask);
next_and_curr_state_mask = bdd_and(dd, state_mask, next_state_mask);
{ /* calculates the initial states */
bdd_ptr bdd_init = BddFsm_get_init(fsm);
bdd_ptr bdd_sinvar = BddFsm_get_state_constraints(fsm);
bdd_ptr bdd_iinvar = BddFsm_get_input_constraints(fsm);
bdd_and_accumulate(dd, &bdd_init, bdd_sinvar);
bdd_and_accumulate(dd, &bdd_init, bdd_iinvar);
bdd_and_accumulate(dd, &bdd_init, state_mask);
init_add = bdd_to_add(dd, bdd_init);
bdd_free(dd, bdd_iinvar);
bdd_free(dd, bdd_sinvar);
bdd_free(dd, bdd_init);
}
{ /* to control dynamic reordering */
dd_reorderingtype method;
int dd_reord_status;
/* Dynamic reordering during monolithic trans can improve performances */
dd_reord_status = dd_reordering_status(dd, &method);
dd_autodyn_enable(dd, method);
{ /* calculates the transition relation */
bdd_ptr bdd_sinvar = BddFsm_get_state_constraints(fsm);
bdd_ptr bdd_nsinvar = BddEnc_state_var_to_next_state_var(enc, bdd_sinvar);
bdd_ptr bdd_iinvar = BddFsm_get_input_constraints(fsm);
bdd_trans = BddFsm_get_monolithic_trans_bdd(fsm);
bdd_and_accumulate(dd, &bdd_trans, bdd_sinvar);
bdd_and_accumulate(dd, &bdd_trans, bdd_nsinvar);
bdd_and_accumulate(dd, &bdd_trans, bdd_iinvar);
bdd_and_accumulate(dd, &bdd_trans, next_and_curr_state_mask);
bdd_and_accumulate(dd, &bdd_trans, input_mask);
/* #define DEBUG_TRANS */
#ifdef DEBUG_TRANS
FILE * p = stdout; // fopen("TRANS.txt", "w");
fprintf(p, "==================================================\n");
fprintf(p, "TRANS\n");
fprintf(p, "==================================================\n");
// print_trans(enc, bdd_trans, p);
dd_printminterm(dd, bdd_trans);
fprintf(p, "==================================================\n");
dd_printminterm(dd, input_mask);
fprintf(p, "==================================================\n");
// fclose(p);
#endif
trans_add = bdd_to_add(dd, bdd_trans);
bdd_free(dd, bdd_iinvar);
bdd_free(dd, bdd_nsinvar);
bdd_free(dd, bdd_sinvar);
}
/* Dynamic reordering is disabled after monolitic
construction. Later it will be re-enabled if it was enable
before entering this block */
dd_autodyn_disable(dd);
/* probability and tau are optional */
if (probs_list != NODE_LIST(NULL)) {
prob_add = Compass_process_prob_list(enc, probs_list, bdd_trans);
}
else prob_add = (add_ptr) NULL;
bdd_free(dd, bdd_trans);
if (tau != (Expr_ptr) NULL) {
tau_add = BddEnc_expr_to_add(enc, tau, Nil);
/* [RC]: This code was disable because it seems masks for input
* var do not work */
/* mask_tau_add = BddEnc_apply_input_vars_mask_add(enc, tau_add); */
/* add_free(dd, tau_add); */
/* tau_add = mask_tau_add; */
}
else
tau_add = (add_ptr) NULL;
if (NODE_LIST(NULL) != ap_list) {
add_ptr expr_add, expr_add_mask;
ListIter_ptr iter;
ap_list_add = NodeList_create();
NODE_LIST_FOREACH(ap_list, iter) {
node_ptr ap_el = (node_ptr)NodeList_get_elem_at(ap_list, iter);
node_ptr lab = car(ap_el);
node_ptr expr = cdr(ap_el);
expr_add = BddEnc_expr_to_add(enc, expr, Nil);
expr_add_mask = BddEnc_apply_state_frozen_vars_mask_add(enc, expr_add);
NodeList_append(ap_list_add, cons(nodemgr, lab, (node_ptr)expr_add_mask));
add_free(dd, expr_add);
/* The expr_add_mask will be freed later when the ap_list_add
will be destroyed */
}
}
void create_bdds(TransitionSystem *model)
{
// printf("%d\ttotal states before merge\n", initial_numstates);
// merge_similar_parents(&PSEUDO_END);
// merge_similar_children(model->pseudo_initial); //merging children spoiles the calculation of support
model->states_size = assign_id_and_collect_labels(model, model->pseudo_initial);
// printf("%d\ttotal states after merge\n", model->states_size);
// printf("%d\tstates removed\n", initial_numstates - model->states_size);
get_transitions(model, NULL, model->pseudo_initial);
init_buddy(model->states_size);
int state_vars = ceil_of_log2_of(model->states_size);
int bdd_vars = state_vars * 2;
bdd_setvarnum(bdd_vars);
BDD unprimed2primed = bdd_addref(0);
model->states_bdds = malloc(sizeof(int *) * model->states_size);
model->states_primed_bdds = malloc(sizeof(int *) * model->states_size);
model->all_states = bdd_addref(0);
//encode states as binary functions
for (int i = 1; i < model->states_size; i++) {
BDD tmp = bdd_addref(1);
BDD tmpp = bdd_addref(1);
for (int j = 0; j < state_vars; j++) {
int test = (i >> (state_vars - 1 - j)) & 1;
if (test == 1) {
tmp = f_bdd_and_with(tmp, bdd_ithvar(j));
tmpp = f_bdd_and_with(tmpp, bdd_ithvar(j + state_vars));
} else {
tmp = f_bdd_and_with(tmp, bdd_nithvar(j));
tmpp = f_bdd_and_with(tmpp, bdd_nithvar(j + state_vars));
}
}
model->states_bdds[i] = bdd_addref(tmp);
model->states_primed_bdds[i] = bdd_addref(tmpp);
model->all_states = f_bdd_or_with(model->all_states, tmp);
BDD tt = bdd_addref(bdd_and(tmp, tmpp));
unprimed2primed = f_bdd_or_with(unprimed2primed, tt);
bdd_delref(tt);
bdd_delref(tmp);
bdd_delref(tmpp);
}
model->pseudo_end = model->states_bdds[PSEUDO_END.id];
//remove pseudo end
BDD tmp = bdd_addref(model->all_states);
bdd_delref(model->all_states);
model->all_states = bdd_apply(tmp, model->pseudo_end, bddop_diff);
bdd_delref(tmp);
model->unprimed2primed = bdd_addref(unprimed2primed);
bdd_delref(unprimed2primed);
//create helper of unprimed and primed variables
BDD unprimed_vars = bdd_addref(1);
BDD primed_vars = bdd_addref(1);
for (int i = 0; i < state_vars; i++) {
unprimed_vars = f_bdd_and_with(unprimed_vars, bdd_ithvar(i));
primed_vars = f_bdd_and_with(primed_vars, bdd_ithvar(i + state_vars));
}
model->unprimed_vars = unprimed_vars;
model->primed_vars = primed_vars;
//create function for transitions
BDD transitions_bdd = bdd_addref(0);
for (int i = 0; i < model->transition_size; i++)
{
// printf("(%d, %d), ", model->transitions[i]->src, model->transitions[i]->dest);
BDD tt = bdd_addref(bdd_and(model->states_bdds[model->transitions[i]->src], model->states_primed_bdds[model->transitions[i]->dest]));
transitions_bdd = f_bdd_or_with(transitions_bdd, tt);
bdd_delref(tt);
}
//transition from end to end to complete Kripke structure
// BDD tt = bdd_addref(bdd_and(model->states_bdds[PSEUDO_END.id], model->states_primed_bdds[PSEUDO_END.id]));
// transitions_bdd = f_bdd_or_with(transitions_bdd, tt);
// bdd_delref(tt);
model->initial_states = 0;
State *child;
// printf("children %d\n", model->pseudo_initial->children_size);
for (int i = 0; i < model->pseudo_initial->children_size; i++)
{
child = model->pseudo_initial->children[i];
if (child == NULL)
continue; // removed
model->initial_states = f_bdd_or_with(model->initial_states, model->states_bdds[child->id]);
}
model->transitions_bdd = transitions_bdd;
for (int i = 0; i < model->activities_size; i++)
{
Labels *l = model->labels[i];
l->states_bdd = bdd_addref(0);
for (int j = 0; j < l->states_size; j++)
{
l->states_bdd = f_bdd_or_with(l->states_bdd, model->states_bdds[l->states[j]]);
}
}
}
int main (int argc, char** argv)
{
int argi = init_sysCx (&argc, &argv);
const int xdomsz = 4;
int xdoms[3];
int xfddidcs[3];
bdd ybdds[3];
bdd satbdd;
int off;
bdd a, b, c, d, e;
if (argi < argc) return 1;
xdoms[0] = xdoms[1] = xdoms[2] = xdomsz;
bdd_init (1000,100);
push_losefn_sysCx (bdd_done);
off = bdd_extvarnum (1);
satbdd = bdd_ithvar (off);
xfddidcs[0] = fdd_extdomain (xdoms, 3);
xfddidcs[1] = xfddidcs[0] + 1;
xfddidcs[2] = xfddidcs[1] + 1;
off = bdd_extvarnum (3);
printf ("y0:%d y1:%d y2:%d\n", off + 0, off + 1, off + 2);
ybdds[0] = bdd_ithvar (off + 0);
ybdds[1] = bdd_ithvar (off + 1);
ybdds[2] = bdd_ithvar (off + 2);
{
int cnt = bdd_getnodenum ();
printf ("Start with %d nodes!\n", cnt);
}
d = satbdd;
{:for (i ; 3)
a = fdd_equals (xfddidcs[i], xfddidcs[(i+1)%3]);
a = bdd_addref (a);
b = bdd_biimp (ybdds[i], ybdds[(i+1)%3]);
b = bdd_addref (b);
e = bdd_imp (a, b);
e = bdd_addref (e);
bdd_delref (a);
bdd_delref (b);
c = d;
d = bdd_and (c, e);
d = bdd_addref (d);
bdd_delref (c);
bdd_delref (e);
}
#if 0
a = bdd_satone (d);
a = bdd_addref (a);
fdd_printset (a);
fputc ('\n', stdout);
bdd_printset (a);
fputc ('\n', stdout);
bdd_delref (a);
#endif
bdd_printtable (d);
bdd_delref (d);
/* fdd_clearall (); */
{
int cnt;
bdd_gbc ();
cnt = bdd_getnodenum ();
printf ("Still have %d nodes!\n", cnt);
}
lose_sysCx ();
return 0;
}
BDD code_range_bdd(uint32_t low_code,uint32_t high_code) {
BDD rval,subrange,srx;
if (low_code<0x80)
rval=bits_range_bdd((low_code<<24),
(high_code>=0x80?
0x7FFFFFFF:
high_code<<24));
else
rval=bddfalse;
if ((low_code<0x800) && (high_code>=0x80)) {
subrange=bits_range_bdd((low_code<0x80?
0xC2800000:
((low_code& 0x3F)<<16)+
((low_code&0x7C0)<<18)+
0xC0800000),
(high_code>=0x800?
0xDFBFFFFF:
((high_code& 0x3F)<<16)+
((high_code&0x7C0)<<18)+
0xC080FFFF));
srx=bdd_addref(bdd_and(subrange,bdd_nithvar(9)));
bdd_delref(subrange);
subrange=bdd_addref(bdd_and(srx,bdd_ithvar(8)));
bdd_delref(srx);
srx=bdd_addref(bdd_or(rval,subrange));
bdd_delref(rval);
bdd_delref(subrange);
rval=srx;
}
if ((low_code<0x10000) && (high_code>=0x800)) {
subrange=bits_range_bdd((low_code<0x800?
0xE0A00000:
((low_code& 0x3F)<<8)+
((low_code& 0xFC0)<<10)+
((low_code&0xF000)<<12)+
0xE0808000),
(high_code>=0x10000?
0xEFBFBFFF:
((high_code& 0x3F)<<8)+
((high_code& 0xFC0)<<10)+
((high_code&0xF000)<<12)+
0xE08080FF));
srx=bdd_addref(bdd_and(subrange,bdd_nithvar(17)));
bdd_delref(subrange);
subrange=bdd_addref(bdd_and(srx,bdd_ithvar(16)));
bdd_delref(srx);
srx=bdd_addref(bdd_and(subrange,bdd_nithvar(9)));
bdd_delref(subrange);
subrange=bdd_addref(bdd_and(srx,bdd_ithvar(8)));
bdd_delref(srx);
srx=bdd_addref(bdd_or(rval,subrange));
bdd_delref(rval);
bdd_delref(subrange);
rval=srx;
}
if (high_code>=0x10000) {
subrange=bits_range_bdd((low_code<0x10000?
0xF0900000:
(low_code& 0x3F)+
((low_code& 0xFC0)<<2)+
((low_code& 0x3F000)<<4)+
((low_code&0x1C0000)<<6)+
0xF0808080),
(high_code& 0x3F)+
((high_code& 0xFC0)<<2)+
((high_code& 0x3F000)<<4)+
((high_code&0x1C0000)<<6)+
0xF0808080);
srx=bdd_addref(bdd_and(subrange,bdd_nithvar(25)));
bdd_delref(subrange);
subrange=bdd_addref(bdd_and(srx,bdd_ithvar(24)));
bdd_delref(srx);
srx=bdd_addref(bdd_and(subrange,bdd_nithvar(17)));
bdd_delref(subrange);
subrange=bdd_addref(bdd_and(srx,bdd_ithvar(16)));
bdd_delref(srx);
srx=bdd_addref(bdd_and(subrange,bdd_nithvar(9)));
bdd_delref(subrange);
subrange=bdd_addref(bdd_and(srx,bdd_ithvar(8)));
bdd_delref(srx);
srx=bdd_addref(bdd_or(rval,subrange));
bdd_delref(rval);
bdd_delref(subrange);
rval=srx;
}
return rval;
}
