├── .gitignore ├── Dockerfile ├── EXAMPLES-llm.md ├── EXAMPLES.md ├── EXTERNAL_FILES ├── CIVL-1.21_5476.tgz ├── CIVL-1.22_5854.tgz └── dot_sarl ├── LICENSE ├── README.md ├── TODO ├── benchmark-hard ├── Egcd3.java ├── Fermat1.java ├── Fermat2.java ├── Freire1.java ├── Freire1_Int.java ├── Geo3.java ├── Knuth.java └── KnuthNoSqrt.java ├── benchmark ├── README.md ├── c │ ├── complexity │ │ ├── cav09_fig1a.c │ │ ├── cav09_fig1d.c │ │ ├── cav09_fig2d.c │ │ ├── cav09_fig3a.c │ │ ├── cav09_fig5b.c │ │ ├── pldi09_ex6.c │ │ ├── pldi09_fig1.c │ │ ├── pldi09_fig2.c │ │ ├── pldi09_fig4_1.c │ │ ├── pldi09_fig4_2.c │ │ ├── pldi09_fig4_3.c │ │ ├── pldi09_fig4_4.c │ │ ├── pldi09_fig4_5.c │ │ ├── popl09_fig2_1.c │ │ ├── popl09_fig2_2.c │ │ ├── popl09_fig3_4.c │ │ ├── popl09_fig4_1.c │ │ ├── popl09_fig4_2.c │ │ ├── popl09_fig4_3.c │ │ └── popl09_fig4_4.c │ ├── hola │ │ ├── 01.dig.c │ │ ├── 02.dig.c │ │ ├── 03.dig.c │ │ ├── 04.dig.c │ │ ├── 05.dig.c │ │ ├── 06.dig.c │ │ ├── 07.dig.c │ │ ├── 08.dig.c │ │ ├── 09.dig.c │ │ ├── 10.dig.c │ │ ├── 11.dig.c │ │ ├── 12.dig.c │ │ ├── 13.dig.c │ │ ├── 14.dig.c │ │ ├── 15.dig.c │ │ ├── 16.dig.c │ │ ├── 17.dig.c │ │ ├── 18.dig.c │ │ ├── 19.dig.c │ │ ├── 20.dig.c │ │ ├── 21.dig.c │ │ ├── 22.dig.c │ │ ├── 23.dig.c │ │ ├── 24.dig.c │ │ ├── 25.dig.c │ │ ├── 26.dig.c │ │ ├── 27.dig.c │ │ ├── 28.dig.c │ │ ├── 29.dig.c │ │ ├── 30.dig.c │ │ ├── 31.dig.c │ │ ├── 32.dig.c │ │ ├── 33.dig.c │ │ ├── 34.dig.c │ │ ├── 35.dig.c │ │ ├── 36.dig.c │ │ ├── 37.dig.c │ │ ├── 38.dig.c │ │ ├── 39.dig.c │ │ ├── 40.dig.c │ │ ├── 41.dig.c │ │ ├── 42.dig.c │ │ ├── 43.dig.c │ │ ├── 44.dig.c │ │ ├── 45.dig.c │ │ └── 46.dig.c │ ├── nla │ │ ├── README.md │ │ ├── bresenham.c │ │ ├── cohencu.c │ │ ├── cohendiv.c │ │ ├── dijkstra.c │ │ ├── divbin.c │ │ ├── egcd.c │ │ ├── egcd2.c │ │ ├── egcd3.c │ │ ├── fermat1.c │ │ ├── fermat2.c │ │ ├── freire1.c │ │ ├── freire1_int.c │ │ ├── freire2.c │ │ ├── geo1.c │ │ ├── geo2.c │ │ ├── geo3.c │ │ ├── hard.c │ │ ├── knuth.c │ │ ├── lcm1.c │ │ ├── lcm2.c │ │ ├── mannadiv.c │ │ ├── prod4br.c │ │ ├── prodbin.c │ │ ├── ps1.c │ │ ├── ps2.c │ │ ├── ps3.c │ │ ├── ps4.c │ │ ├── ps5.c │ │ ├── ps6.c │ │ └── sqrt1.c │ └── nla_full │ │ ├── README.md │ │ ├── a.out │ │ ├── cohencu.c │ │ ├── cohendiv.c │ │ ├── dijkstra.c │ │ ├── divbin.c │ │ ├── egcd.c │ │ ├── egcd2.c │ │ ├── egcd3.c │ │ ├── fail │ │ ├── freire1.c │ │ ├── freire2.c │ │ ├── knuth.c │ │ └── ps1.c │ │ ├── fermat1.c │ │ ├── fermat2.c │ │ ├── freire1_int.c │ │ ├── geo1.c │ │ ├── geo2.c │ │ ├── geo3.c │ │ ├── hard.c │ │ ├── knuth_nosqrt.c │ │ ├── lcm1.c │ │ ├── lcm2.c │ │ ├── mannadiv.c │ │ ├── printf │ │ └── cohendiv.c │ │ ├── prod4br.c │ │ ├── prodbin.c │ │ ├── ps2.c │ │ ├── ps3.c │ │ ├── ps4.c │ │ ├── ps5.c │ │ ├── ps6.c │ │ └── sqrt1.c └── java │ ├── complexity │ ├── Cav09_Fig1a.java │ ├── Cav09_Fig1d.java │ ├── Cav09_Fig2d.java │ ├── Cav09_Fig3a.java │ ├── Cav09_Fig5b.java │ ├── PLDI09_Ex6.java │ ├── PLDI09_Fig2.java │ ├── PLDI09_Fig4_1.java │ ├── PLDI09_Fig4_2.java │ ├── PLDI09_Fig4_3.java │ ├── PLDI09_Fig4_4.java │ ├── PLDI09_Fig4_5.java │ ├── POPL09_Fig2_1.java │ ├── POPL09_Fig2_2.java │ ├── POPL09_Fig3_4.java │ ├── POPL09_Fig4_1.java │ ├── POPL09_Fig4_2.java │ ├── POPL09_Fig4_3.java │ ├── POPL09_Fig4_4.java │ ├── notused │ │ └── Trouble.java │ └── tests │ │ ├── PLDI09_Fig2.java │ │ └── PLDI09_Fig4_5.java │ ├── deleteme │ ├── Cav09_Fig1a.java │ ├── Cav09_Fig1d.java │ ├── Cav09_Fig2d.java │ ├── Cav09_Fig3a.java │ ├── Cav09_Fig5b.java │ ├── PLDI09_Ex6.java │ ├── PLDI09_Fig2.java │ ├── PLDI09_Fig4_1.java │ ├── PLDI09_Fig4_2.java │ ├── PLDI09_Fig4_3.java │ ├── PLDI09_Fig4_4.java │ ├── PLDI09_Fig4_5.java │ ├── POPL09_Fig2_1.java │ ├── POPL09_Fig2_2.java │ ├── POPL09_Fig3_4.java │ ├── POPL09_Fig4_1.java │ ├── POPL09_Fig4_2.java │ ├── POPL09_Fig4_3.java │ └── POPL09_Fig4_4.java │ ├── hola │ ├── H01.java │ ├── H02.java │ ├── H03.java │ ├── H04.java │ ├── H05.java │ ├── H06.java │ ├── H07.java │ ├── H08.java │ ├── H09.java │ ├── H10.java │ ├── H11.java │ ├── H12.java │ ├── H13.java │ ├── H14.java │ ├── H15.java │ ├── H16.java │ ├── H17.java │ ├── H18.java │ ├── H19.java │ ├── H20.java │ ├── H21.java │ ├── H22.java │ ├── H23.java │ ├── H24.java │ ├── H25.java │ ├── H26.java │ ├── H27.java │ ├── H28.java │ ├── H29.java │ ├── H30.java │ ├── H31.java │ ├── H32.java │ ├── H33.java │ ├── H34.java │ ├── H35.java │ ├── H36.java │ ├── H37.java │ ├── H38.java │ ├── H39.java │ ├── H40.java │ ├── H41.java │ ├── H42.java │ ├── H43.java │ ├── H44.java │ ├── H45.java │ └── H46.java │ ├── mp │ ├── OddEven2.java │ ├── OddEven3.java │ ├── OddEven4.java │ ├── OddEven5.java │ ├── PartialDecrement1.java │ ├── PartialDecrement2.java │ ├── PartialDecrement3.java │ ├── PartialDecrement4.java │ ├── PartialDecrement5.java │ ├── PartialIncrement1.java │ ├── PartialIncrement2.java │ ├── PartialIncrement3.java │ ├── PartialIncrement4.java │ ├── PartialIncrement5.java │ ├── StrnCopy.java │ └── ignore │ │ ├── OddEven6.java │ │ ├── OddEven7.java │ │ ├── OddEven8.java │ │ └── old.java │ ├── nla │ ├── Bresenham.java │ ├── CohenCu.java │ ├── CohenDiv.java │ ├── Dijkstra.java │ ├── DivBin.java │ ├── Egcd.java │ ├── Egcd2.java │ ├── Egcd3.java │ ├── Fermat1.java │ ├── Fermat2.java │ ├── Freire1_Int.java │ ├── Freire2_Int.java │ ├── Geo1.java │ ├── Geo2.java │ ├── Geo3.java │ ├── Hard.java │ ├── KnuthNoSqrt.java │ ├── Lcm1.java │ ├── Lcm2.java │ ├── MannaDiv.java │ ├── Prod4br.java │ ├── ProdBin.java │ ├── Ps2.java │ ├── Ps3.java │ ├── Ps4.java │ ├── Ps5.java │ ├── Ps6.java │ ├── README.md │ ├── Sqrt1.java │ ├── fail │ │ ├── Dijkstra1Loc.java │ │ ├── Egcd2_bound.java │ │ ├── Egcd3.java │ │ ├── Egcd3_1loc_printf.java │ │ ├── Egcd3_bound.java │ │ ├── Fermat1A.java │ │ ├── Freire1.java │ │ ├── Freire2.java │ │ ├── Knuth.java │ │ └── Ps1.java │ └── printf │ │ ├── Bresenham.java │ │ ├── Fermat1.java │ │ └── out │ └── nla_full │ ├── Bresenham.java │ ├── CohenCu.java │ ├── CohenDiv.java │ ├── Dijkstra.java │ ├── DivBin.java │ ├── Egcd.java │ ├── Fermat1.java │ ├── Fermat2.java │ ├── Freire1_Int.java │ ├── Geo1.java │ ├── Geo2.java │ ├── Geo3.java │ ├── Hard.java │ ├── Lcm1.java │ ├── Lcm2.java │ ├── MannaDiv.java │ ├── Prod4br.java │ ├── ProdBin.java │ ├── Ps1.java │ ├── Ps2.java │ ├── Ps3.java │ ├── Ps4.java │ ├── Ps5.java │ ├── Ps6.java │ ├── Sqrt1.java │ ├── examples │ ├── CohenDiv1Loc.java │ ├── CohenDivComplexity.java │ ├── CohenDivMotiv.java │ ├── CohenDivMotivRun.java │ ├── MannaDivRun.java │ ├── Sqrt11Loc.java │ ├── Test1.java │ ├── Test2.java │ ├── Test4.java │ └── benchmark_test │ │ ├── CohenDiv1Loc.java │ │ └── DivBin1Loc.java │ ├── fail │ ├── Egcd2.java │ ├── Egcd3.java │ ├── Freire1.java │ ├── Freire2.java │ ├── Knuth.java │ ├── KnuthNoSqrt.java │ └── report.txt │ ├── hard │ └── Egcd2_bound.java │ └── printf │ └── CohenDiv.java ├── docs └── index.md ├── examples ├── SymInferASE │ ├── complexity │ │ ├── README │ │ ├── gulwani_cav09 │ │ │ ├── Fig1a.java │ │ │ ├── Fig1d.java │ │ │ ├── Fig2d.java │ │ │ ├── Fig3a.java │ │ │ ├── Fig5b.java │ │ │ ├── fig1a.c │ │ │ ├── fig1d.c │ │ │ ├── fig2a.c │ │ │ ├── fig2d.c │ │ │ ├── fig3a.c │ │ │ └── fig5b.c │ │ ├── gulwani_pldi09 │ │ │ ├── Fig2.java │ │ │ ├── Fig2Print.java │ │ │ ├── Fig4_1.java │ │ │ ├── Fig4_2.java │ │ │ ├── Fig4_3.java │ │ │ ├── Fig4_4.java │ │ │ ├── Fig4_5.java │ │ │ ├── bytecode │ │ │ │ ├── Fig2Exp.java │ │ │ │ └── Fig2Printf.java │ │ │ ├── ex6.c │ │ │ ├── ex6.c.orig │ │ │ ├── fig1.c │ │ │ ├── fig2.c │ │ │ ├── fig4_1.c │ │ │ ├── fig4_2.c │ │ │ ├── fig4_3.c │ │ │ ├── fig4_4.c │ │ │ └── fig4_5.c │ │ └── gulwani_popl09 │ │ │ ├── Fig2_1.c │ │ │ ├── Fig2_1.java │ │ │ ├── Fig2_2.c │ │ │ ├── Fig2_2.java │ │ │ ├── Fig3_4.c │ │ │ ├── Fig3_4.java │ │ │ ├── Fig4_1.c │ │ │ ├── Fig4_1.java │ │ │ ├── Fig4_2.c │ │ │ ├── Fig4_2.java │ │ │ ├── Fig4_3.c │ │ │ ├── Fig4_3.java │ │ │ ├── Fig4_4.c │ │ │ └── Fig4_4.java │ ├── hola │ │ ├── 01.dig.c │ │ ├── 02.dig.c │ │ ├── 03.dig.c │ │ ├── 04.dig.c │ │ ├── 05.dig.c │ │ ├── 06.dig.c │ │ ├── 07.dig.c │ │ ├── 08.dig.c │ │ ├── 09.dig.c │ │ ├── 10.dig.c │ │ ├── 11.dig.c │ │ ├── 12.dig.c │ │ ├── 13.dig.c │ │ ├── 14.dig.c │ │ ├── 15.dig.c │ │ ├── 16.dig.c │ │ ├── 17.dig.c │ │ ├── 18.dig.c │ │ ├── 19.dig.c │ │ ├── 20.dig.c │ │ ├── 21.dig.c │ │ ├── 22.dig.c │ │ ├── 23.dig.c │ │ ├── 24.dig.c │ │ ├── 25.dig.c │ │ ├── 26.dig.c │ │ ├── 27.dig.c │ │ ├── 28.dig.c │ │ ├── 29.dig.c │ │ ├── 30.dig.c │ │ ├── 31.dig.c │ │ ├── 32.dig.c │ │ ├── 33.dig.c │ │ ├── 34.dig.c │ │ ├── 35.dig.c │ │ ├── 36.dig.c │ │ ├── 37.dig.c │ │ ├── 38.dig.c │ │ ├── 39.dig.c │ │ ├── 40.dig.c │ │ ├── 41.dig.c │ │ ├── 42.dig.c │ │ ├── 43.dig.c │ │ ├── 44.dig.c │ │ ├── 45.dig.c │ │ ├── 46.dig.c │ │ ├── H01.java │ │ ├── H02.java │ │ ├── H03.java │ │ ├── H04.java │ │ ├── H05.java │ │ ├── H06.java │ │ ├── H07.java │ │ ├── H08.java │ │ ├── H09.java │ │ ├── H10.java │ │ ├── H11.java │ │ ├── H12.java │ │ ├── H13.java │ │ ├── H14.java │ │ ├── H15.java │ │ ├── H16.java │ │ ├── H17.java │ │ ├── H18.java │ │ ├── H19.java │ │ ├── H20.java │ │ ├── H21.java │ │ ├── H22.java │ │ ├── H23.java │ │ ├── H24.java │ │ ├── H25.java │ │ ├── H26.java │ │ ├── H27.java │ │ ├── H28.java │ │ ├── H29.java │ │ ├── H30.java │ │ ├── H31.java │ │ ├── H32.java │ │ ├── H33.java │ │ ├── H34.java │ │ ├── H35.java │ │ ├── H36.java │ │ ├── H37.java │ │ ├── H38.java │ │ ├── H39.java │ │ ├── H40.java │ │ ├── H41.java │ │ ├── H42.java │ │ ├── H43.java │ │ ├── H44.java │ │ ├── H45.java │ │ ├── H46.java │ │ ├── bm_hola │ │ │ └── orig_bms │ │ │ │ ├── 01.c │ │ │ │ ├── 02.c │ │ │ │ ├── 03.c │ │ │ │ ├── 04.c │ │ │ │ ├── 05.c │ │ │ │ ├── 06.c │ │ │ │ ├── 07.c │ │ │ │ ├── 08.c │ │ │ │ ├── 09.c │ │ │ │ ├── 10.c │ │ │ │ ├── 11.c │ │ │ │ ├── 12.c │ │ │ │ ├── 13.c │ │ │ │ ├── 14.c │ │ │ │ ├── 15.c │ │ │ │ ├── 16.c │ │ │ │ ├── 17.c │ │ │ │ ├── 18.c │ │ │ │ ├── 19.c │ │ │ │ ├── 20.c │ │ │ │ ├── 21.c │ │ │ │ ├── 22.c │ │ │ │ ├── 23.c │ │ │ │ ├── 24.c │ │ │ │ ├── 25.c │ │ │ │ ├── 26.c │ │ │ │ ├── 27.c │ │ │ │ ├── 28.c │ │ │ │ ├── 29.c │ │ │ │ ├── 30.c │ │ │ │ ├── 31.c │ │ │ │ ├── 32.c │ │ │ │ ├── 33.c │ │ │ │ ├── 34.c │ │ │ │ ├── 35.c │ │ │ │ ├── 36.c │ │ │ │ ├── 37.c │ │ │ │ ├── 38.c │ │ │ │ ├── 39.c │ │ │ │ ├── 40.c │ │ │ │ ├── 41.c │ │ │ │ ├── 42.c │ │ │ │ ├── 43.c │ │ │ │ ├── 44.c │ │ │ │ ├── 45.c │ │ │ │ └── 46.c │ │ └── skip │ │ │ ├── 01.dig.c │ │ │ ├── 02.dig.c │ │ │ ├── 03.dig.c │ │ │ ├── 04.dig.c │ │ │ ├── 05.dig.c │ │ │ ├── 06.dig.c │ │ │ ├── 07.dig.c │ │ │ ├── 08.dig.c │ │ │ ├── 09.dig.c │ │ │ ├── 10.dig.c │ │ │ ├── 11.dig.c │ │ │ ├── 12.dig.c │ │ │ ├── 13.dig.c │ │ │ ├── 14.dig.c │ │ │ ├── 15.dig.c │ │ │ ├── 16.dig.c │ │ │ ├── 17.dig.c │ │ │ ├── 18.dig.c │ │ │ ├── 19.dig.c │ │ │ ├── 20.dig.c │ │ │ ├── 21.dig.c │ │ │ ├── 22.dig.c │ │ │ ├── 23.dig.c │ │ │ ├── 24.dig.c │ │ │ ├── 25.dig.c │ │ │ ├── 26.dig.c │ │ │ ├── 27.dig.c │ │ │ ├── 28.dig.c │ │ │ ├── 29.dig.c │ │ │ ├── 30.dig.c │ │ │ ├── 31.dig.c │ │ │ ├── 32.dig.c │ │ │ ├── 33.dig.c │ │ │ ├── 34.dig.c │ │ │ ├── 35.dig.c │ │ │ ├── 36.dig.c │ │ │ ├── 37.dig.c │ │ │ ├── 38.dig.c │ │ │ ├── 39.dig.c │ │ │ └── 40.dig.c │ └── nla │ │ ├── CohenCu.java │ │ ├── CohenDiv.java │ │ ├── Dijkstra.java │ │ ├── DivBin.java │ │ ├── Egcd.java │ │ ├── Egcd2.java │ │ ├── Egcd3.java │ │ ├── Fermat1.java │ │ ├── Fermat2.java │ │ ├── Freire1.java │ │ ├── Freire2.java │ │ ├── Freire2A.java │ │ ├── Geo1.java │ │ ├── Geo2.java │ │ ├── Geo3.java │ │ ├── Hard.java │ │ ├── Knuth.java │ │ ├── Lcm1.java │ │ ├── Lcm2.java │ │ ├── MannaDiv.java │ │ ├── Prod4br.java │ │ ├── ProdBin.java │ │ ├── Ps1.java │ │ ├── Ps2.java │ │ ├── Ps3.java │ │ ├── Ps4.java │ │ ├── Ps5.java │ │ ├── Ps6.java │ │ ├── Sqrt1.java │ │ ├── bytecode │ │ ├── CohenDivComplexity.java │ │ ├── Ps61.java │ │ └── Test1.java │ │ ├── cohendiv1.c │ │ └── cohendivtest.c ├── acsl │ └── c │ │ ├── abs.c │ │ ├── abs_implementation.c │ │ ├── average.c │ │ ├── distance.c │ │ ├── distance_abs.c │ │ ├── factorial.c │ │ ├── factorial_rec.c │ │ ├── fib_rec.c │ │ ├── gcd.c │ │ ├── gcd_raw.c │ │ ├── gcd_rec.c │ │ ├── nod.c │ │ ├── sign.c │ │ ├── sum.c │ │ └── sum35.c ├── bit-gf.craft.c ├── cohendiv.c ├── examples │ ├── Chanh1.java │ ├── CohenDivFake.java │ ├── Decreasing_const_bound_nonterm_dig.java │ ├── Ex0.java │ ├── Ex1.java │ ├── Ex2.java │ ├── Ex3.java │ ├── Ex4.java │ ├── Ex5.java │ ├── Ex6.java │ ├── ExUnreach.java │ ├── MP.java │ ├── MP1.java │ ├── MP2.java │ ├── MP_long.java │ ├── Median.java │ ├── NoInput.java │ ├── Oct1.java │ ├── OddEven2.java │ ├── OddEven3.java │ ├── chanh.c │ ├── cohencu_1loc.c │ ├── cohendiv_1loc.c │ ├── ex0.c │ ├── ex1.c │ ├── ex2.c │ ├── ex4.c │ ├── example.c │ ├── linear.c │ └── t.java ├── miscs │ ├── ex2.c │ ├── mbedtls_secure_cmp.c │ └── univariate_poly.c ├── paper │ ├── Bresenham.java │ ├── CohenDiv.java │ ├── CohenDiv1Loc.java │ ├── CohenDiv1LocOctaTest.java │ ├── CohenDivOctaTest.java │ ├── CohenDivPost.java │ ├── Sqrt1.java │ ├── Sqrt1NonLin.java │ ├── Sqrt1OctaTest.java │ ├── Sqrt1OctaTest_Vu.java │ ├── Tripple.java │ ├── TrippleOctaTest.java │ ├── ineqHigherCoefTest.txt │ └── nonLinearIneqTest.txt ├── t.c ├── t2.c ├── t2a.c ├── test1.c ├── tools │ └── cohendiv_civl.c ├── traces │ ├── CohenDiv.tcs │ ├── CohenDiv_1loc.csv │ ├── CohenDiv_test_traces.tcs │ ├── Cook_cacm11_fig1.tcs │ ├── aes_mul.l0.tcs │ ├── aes_mul.l1.tcs │ ├── aes_mul.tcs │ ├── cohendiv.csv │ ├── cohendiv_fulllocs.csv │ ├── congruences1.csv │ ├── cyrus1.csv │ ├── ex.csv │ ├── ex1.csv │ ├── ex2.csv │ ├── ex4.csv │ ├── ex5.csv │ ├── ex_float.csv │ ├── paper_nested.csv │ ├── paper_nested2.csv │ ├── paper_nested_repeatelem.csv │ ├── test1.tcs │ ├── timos.csv │ └── traces_vtrace1.tcs └── transform │ ├── cohendiv-1.c │ ├── cohendiv-2.c │ ├── cohendiv-preprocess.c │ ├── cohendiv-printf.c │ ├── cohendiv-symtool.c │ ├── cohendiv.c │ ├── cohendiv.c.instr.c │ ├── simple.c │ └── simple.c.instr.c └── src ├── alg.py ├── algebraicaxioms ├── java │ ├── Axioms.java │ ├── JParser.java │ ├── Miscs.java │ ├── README.txt │ ├── examples │ │ └── StackExample.java │ └── old │ │ ├── Arg.java │ │ ├── Drivers.java │ │ ├── Fun.java │ │ ├── Node.java │ │ ├── Node1.java │ │ ├── T.java │ │ └── Term.java └── python │ ├── examples │ ├── __init__.py │ ├── ex1.py │ ├── ex2.py │ ├── stack.py │ ├── string.py │ └── stringbuffer.py │ └── src │ ├── JLinkedList.py │ ├── JStack.py │ ├── JString.py │ ├── TT.java │ ├── Test.java │ ├── Test.py │ ├── Test1.java │ ├── TestT.java │ ├── TestT1.java │ ├── TestVu.java │ ├── __init__.py │ ├── alg.py │ ├── alg_lang.py │ ├── alg_miscs.py │ ├── config.py │ ├── eqfun.py │ ├── ex1.py │ ├── ex2.py │ ├── infer_axioms.py │ ├── java │ └── Perms.java │ ├── learn │ ├── MyLinkedList.java │ └── MyStringTest.java │ ├── mytyp.py │ ├── out │ ├── stringbuffer.py │ ├── t.py │ ├── term.py │ ├── todo │ ├── unused.py │ └── vu_common.py ├── analysis.py ├── beta ├── beta.py ├── binsearch.py ├── cohendiv.c ├── kip │ └── kip_test_nla.py ├── kip1 ├── ltl.py ├── max_deg.py ├── myarray.py ├── poly │ ├── base.py │ └── mp.py ├── t.c ├── t.py ├── t1.py └── varDeg.py ├── c_instrument.py ├── data ├── prog.py ├── symstates.py └── traces.py ├── dig.py ├── helpers ├── miscs.py ├── vcommon.py └── z3utils.py ├── infer ├── __init__.py ├── congruence.py ├── eqt.py ├── infer.py ├── inv.py ├── mp.py ├── nested_array.py ├── oct.py ├── prepost.py └── prepost_infer.py ├── java ├── CollectInfo.java ├── Instrument.java ├── InvariantListenerVu.java ├── JPFInstr.java ├── Makefile ├── MyConst.java ├── PrintInstr.java └── asm-all-5.2.jar ├── kip.py ├── ocaml ├── Makefile ├── common.ml ├── instr.ml └── verify.ml ├── preconds.py ├── prover ├── kip.py ├── miscs.py ├── scr.py └── tests │ ├── invs_mpp_bubble.py │ ├── invs_mpp_dig.py │ ├── invs_mpp_oddeven.py │ ├── invs_mpp_partial.py │ ├── invs_nla_dig.py │ ├── invs_nla_dig2.py │ ├── kip_test_common.py │ ├── kip_test_common_del.py │ ├── kip_test_mpp.py │ └── nla.py ├── settings.py ├── tmp.py └── todo.txt /EXTERNAL_FILES/CIVL-1.21_5476.tgz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dynaroars/dig/7e1ebec4899d7687607e4fdd4c284dd835d68eec/EXTERNAL_FILES/CIVL-1.21_5476.tgz -------------------------------------------------------------------------------- /EXTERNAL_FILES/CIVL-1.22_5854.tgz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dynaroars/dig/7e1ebec4899d7687607e4fdd4c284dd835d68eec/EXTERNAL_FILES/CIVL-1.22_5854.tgz -------------------------------------------------------------------------------- /EXTERNAL_FILES/dot_sarl: -------------------------------------------------------------------------------- 1 | prover { 2 | aliases = z3; 3 | kind = Z3; 4 | version = "4.12.6 - 64 bit"; 5 | path = "/root/miniconda3/bin/z3"; 6 | timeout = 10.0; 7 | showQueries = false; 8 | showInconclusives = false; 9 | showErrors = true; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /benchmark-hard/Freire1.java: -------------------------------------------------------------------------------- 1 | public class Freire1 { 2 | public static void vtrace1(float a, float x, float r){} 3 | public static void vtrace2(float a, float x, float r){} 4 | 5 | public static void main (String[] args) { 6 | } 7 | 8 | public static void mainQ(float a) { 9 | float x = a/2.0f; 10 | float r = 0; 11 | 12 | while(true){ 13 | vtrace1(a,x,r); 14 | //assert((float)a == 2*x + r*r - r); 15 | if (!(x>r)) break; 16 | x = x - r; 17 | r = r + 1; 18 | } 19 | 20 | vtrace2(a,x,r); 21 | //assert((float)a == 2*x + r*r - r); 22 | //return r; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /benchmark-hard/Freire1_Int.java: -------------------------------------------------------------------------------- 1 | public class Freire1_Int { 2 | public static void vtrace1(int a, int x, int r){} 3 | 4 | public static void main (String[] args) { 5 | } 6 | 7 | public static int mainQ(int x) { 8 | int a = x * 2; 9 | int r = 0; 10 | 11 | while(true){ 12 | vtrace1(a,x,r); 13 | //assert((float)a == 2*x + r*r - r); 14 | if (!(x>r)) break; 15 | x = x - r; 16 | r = r + 1; 17 | } 18 | 19 | 20 | return r; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /benchmark/README.md: -------------------------------------------------------------------------------- 1 | NLA: programs with nonlinear invariants 2 | -------------------------------------------------------------------------------- /benchmark/c/complexity/cav09_fig1a.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace_post(int m, int tCtr){} 6 | 7 | int mainQ(int m){ 8 | int x = 0; 9 | int y = 0; 10 | int tCtr = 0; 11 | while(x < 100){ 12 | if (y < m){ 13 | y++; 14 | } 15 | else{ 16 | x++; 17 | } 18 | tCtr++; 19 | } 20 | 21 | vtrace_post(m, tCtr); 22 | //dig2: m*t - (t*t) - 100*m + 200*t - 10000 == 0 23 | //solve for t: t == m + 100, t == 100 24 | return 0; 25 | } 26 | 27 | 28 | void main(int argc, char **argv){ 29 | mainQ(atoi(argv[1])); 30 | } 31 | -------------------------------------------------------------------------------- /benchmark/c/complexity/cav09_fig1d.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace_post(int m, int tCtr){} 6 | 7 | int mainQ(int m){ 8 | 9 | int x = 0; 10 | int y = 0; 11 | int tCtr = 0; 12 | while(x < 100 && y < m){ 13 | y++; 14 | tCtr++; 15 | } 16 | while(x < 100 && y >= m){ 17 | x++; 18 | tCtr++; 19 | } 20 | 21 | vtrace_post(m, tCtr); 22 | //dig2: m*t - (t*t) - 100*m + 200*t - 10000 == 0 23 | //solve for t: t == m + 100, t == 100 24 | return 0; 25 | } 26 | 27 | 28 | void main(int argc, char **argv){ 29 | mainQ(atoi(argv[1])); 30 | } 31 | -------------------------------------------------------------------------------- /benchmark/c/complexity/cav09_fig3a.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace_post(int n, int tCtr){} 6 | 7 | int mainQ(int n){ 8 | int x = 0; 9 | int y = 0; 10 | int tCtr = 0; 11 | while(x < n){ 12 | y = x; 13 | while (y < n){ 14 | y++; 15 | tCtr++; 16 | } 17 | 18 | x=y+1; 19 | } 20 | vtrace_post(n, tCtr); 21 | //%%%traces: int n, int t 22 | //dig2: n*t - (t*t) == 0, -t <= 0, n - t <= 0 23 | return 0; 24 | } 25 | 26 | 27 | void main(int argc, char **argv){ 28 | mainQ(atoi(argv[1])); 29 | } 30 | -------------------------------------------------------------------------------- /benchmark/c/complexity/cav09_fig5b.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace_post(int a, int n, int y, int x, int tCtr){} 6 | 7 | 8 | int mainQ(int a, int n){ 9 | int x = 0; 10 | int y = a; 11 | int tCtr = 0; 12 | while(x < n){ 13 | y++; 14 | x = x + y; 15 | tCtr++; 16 | } 17 | 18 | //dig2: (y*y) - (a*a) - 2*x + y - a == 0, -x <= 0, n - x <= 0, t - y + a == 0, -y + a <= 0 19 | vtrace_post(a, n, y, x, tCtr); 20 | 21 | return 0; 22 | } 23 | 24 | 25 | void main(int argc, char **argv){ 26 | mainQ(atoi(argv[1]), atoi(argv[2])); 27 | } 28 | /*same as Fig 4_3 Gulwani pldi 09*/ 29 | -------------------------------------------------------------------------------- /benchmark/c/complexity/pldi09_fig1.c: -------------------------------------------------------------------------------- 1 | /*See code in pldi Fig4_1*/ 2 | -------------------------------------------------------------------------------- /benchmark/c/hola/01.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int x, int y){} 6 | 7 | void mainQ(int n) { 8 | vassume(n > 0); 9 | int x = 1; 10 | int y = 1; 11 | int j = 0; 12 | 13 | while (j < n) { 14 | int t1 = x; 15 | int t2 = y; 16 | x = t1 + t2; 17 | y = t1 + t2; 18 | j = j + 1; 19 | } 20 | vtrace(x, y); 21 | 22 | //assert(y >= 1); 23 | } 24 | 25 | void main(int argc, char *argv[]) { 26 | mainQ(atoi(argv[1])); 27 | } 28 | -------------------------------------------------------------------------------- /benchmark/c/hola/02.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void vassume(int b){} 4 | void vtrace(int x, int y){} 5 | 6 | 7 | void mainQ(int n) { 8 | vassume(n > 0); 9 | int i = 1; 10 | int j = 0; 11 | int z = i - j; 12 | int x = 0; 13 | int y = 0; 14 | int w = 0; 15 | int u = 0; 16 | 17 | while (u < n) { 18 | z += x + y + w; 19 | y++; 20 | if (z % 2 == 1) x++; 21 | w += 2; 22 | u = u + 1; 23 | } 24 | 25 | vtrace(x, y); 26 | //assert(x == y); 27 | } 28 | 29 | void main(int argc, char *argv[]) { 30 | mainQ(atoi(argv[1])); 31 | } 32 | -------------------------------------------------------------------------------- /benchmark/c/hola/03.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void vassume(int b){} 4 | void vtrace(int i){} 5 | 6 | 7 | void mainQ(int i, int n, int l) { 8 | vassume(l > 0); 9 | int t = 0; 10 | int k = 0; 11 | 12 | for (k = 1; k < n; k++) { 13 | 14 | for (i = l; i < n; i++) { 15 | t = t + 1; 16 | } 17 | 18 | for (i = l; i < n; i++) { 19 | vtrace(i); 20 | //assert(1 <= i) 21 | t = t + 1; 22 | } 23 | } 24 | } 25 | 26 | void main(int argc, char *argv[]) { 27 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 28 | } 29 | -------------------------------------------------------------------------------- /benchmark/c/hola/04.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int y){} 6 | 7 | void mainQ(int y) { 8 | int x = -50; 9 | 10 | while (x < 0) { 11 | x = x + y; 12 | y++; 13 | } 14 | 15 | vtrace(y); 16 | //assert(y > 0); 17 | } 18 | 19 | void main(int argc, char *argv[]) { 20 | mainQ(atoi(argv[1])); 21 | } 22 | -------------------------------------------------------------------------------- /benchmark/c/hola/05.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void vassume(int b){} 4 | void vtrace(int i, int j){} 5 | 6 | 7 | void mainQ(int flag, int n) { 8 | vassume(n > 0); 9 | int j = 0; 10 | int i = 0; 11 | int x = 0; 12 | int y = 0; 13 | int u = 0; 14 | 15 | while (u < n) { 16 | u++; 17 | x++; 18 | y++; 19 | i += x; 20 | j += y; 21 | if (flag != 0) j += 1; 22 | } 23 | vtrace(i,j); 24 | //assert(j >= i); 25 | } 26 | 27 | void main(int argc, char *argv[]) { 28 | mainQ(atoi(argv[1]), atoi(argv[2])); 29 | } 30 | -------------------------------------------------------------------------------- /benchmark/c/hola/07.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int a, int b, int n){} 6 | 7 | 8 | void mainQ(int n, int u1) { 9 | vassume(n >= 0&& u1 > 0); 10 | 11 | int a = 0; 12 | int b = 0; 13 | int i = 0; 14 | int u = 0; 15 | 16 | while (i < n) { 17 | if (u < u1) { 18 | a = a + 1; 19 | b = b + 2; 20 | } else { 21 | a = a + 2; 22 | b = b + 1; 23 | } 24 | i = i + 1; 25 | u++; 26 | } 27 | vtrace(a, b, n); 28 | //assert(a + b == 3 * n); 29 | } 30 | 31 | void main(int argc, char *argv[]) { 32 | mainQ(atoi(argv[1]), atoi(argv[2])); 33 | } 34 | -------------------------------------------------------------------------------- /benchmark/c/hola/10.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int x, int y){} 6 | 7 | 8 | void mainQ(int u1) { 9 | vassume(u1 > 0); 10 | int i1 = 0; 11 | int w = 1; 12 | int z = 0; 13 | int x = 0; 14 | int y = 0; 15 | 16 | while (i1 < u1) { 17 | i1++; 18 | if (w == 1) { 19 | x++; 20 | w = 0; 21 | }; 22 | if (z == 0) { 23 | y++; 24 | z = 1; 25 | }; 26 | } 27 | 28 | vtrace(x, y); 29 | //assert(x == y); 30 | } 31 | 32 | void main(int argc, char *argv[]) { 33 | mainQ(atoi(argv[1])); 34 | } 35 | -------------------------------------------------------------------------------- /benchmark/c/hola/11.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int j, int x){} 6 | 7 | void mainQ(void) { 8 | int j = 0; 9 | int x = 100; 10 | int i = 0; 11 | 12 | for (i = 0; i < x; i++) { 13 | j = j + 2; 14 | } 15 | vtrace(j, x); 16 | //assert(j == 2 * x); 17 | } 18 | 19 | void main(int argc, char *argv[]) { 20 | mainQ(); 21 | } 22 | -------------------------------------------------------------------------------- /benchmark/c/hola/13.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int j, int k){} 6 | 7 | void mainQ(int flag, int u1) { 8 | vassume(u1 > 0); 9 | int j = 2; 10 | int k = 0; 11 | int i0 = 0; 12 | 13 | while (i0 < u1) { 14 | i0++; 15 | if (flag != 0) 16 | j = j + 4; 17 | else { 18 | j = j + 2; 19 | k = k + 1; 20 | } 21 | } 22 | 23 | vtrace(j, k); 24 | //%%%traces: int j, int k 25 | //if (k != 0) assert(j == 2 * k + 2); 26 | } 27 | 28 | void main(int argc, char *argv[]) { 29 | mainQ(atoi(argv[1]), atoi(argv[2])); 30 | } 31 | -------------------------------------------------------------------------------- /benchmark/c/hola/14.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int a, int m){} 6 | 7 | 8 | void mainQ(int m, int u4) { 9 | vassume(m > 0); 10 | 11 | int a = 0; 12 | int j = 0; 13 | for (j = 1; j <= m; j++) { 14 | if (u4) 15 | a++; 16 | else 17 | a--; 18 | } 19 | 20 | vtrace(a, m); 21 | //assert(a >= 0 - m); 22 | //assert(a <= m); 23 | } 24 | 25 | void main(int argc, char *argv[]) { 26 | mainQ(atoi(argv[1]), atoi(argv[2])); 27 | } 28 | -------------------------------------------------------------------------------- /benchmark/c/hola/15.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int k){} 6 | 7 | void mainQ(int n, int k) { 8 | vassume(n > 0); 9 | vassume(k > n); 10 | 11 | int j = 0; 12 | while (j < n) { 13 | j++; 14 | k--; 15 | } 16 | 17 | vtrace(k); 18 | //assert(k >= 0); 19 | } 20 | 21 | void main(int argc, char *argv[]) { 22 | mainQ(atoi(argv[1]), atoi(argv[2])); 23 | } 24 | -------------------------------------------------------------------------------- /benchmark/c/hola/16.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int i, int j, int y){} 6 | 7 | void mainQ(int i, int j) { 8 | int x = i; 9 | int y = j; 10 | 11 | while (x != 0) { 12 | x--; 13 | y--; 14 | } 15 | //%%%traces: int i, int j, int y 16 | vtrace(i, j, y); 17 | //if (i == j) assert(y == 0); 18 | } 19 | 20 | void main(int argc, char *argv[]) { 21 | mainQ(atoi(argv[1]), atoi(argv[2])); 22 | } 23 | -------------------------------------------------------------------------------- /benchmark/c/hola/17.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int k, int n){} 6 | 7 | 8 | void mainQ(int n) { 9 | vassume(n > 0); 10 | int k = 1; 11 | int i = 1; 12 | int j = 0; 13 | 14 | while (i < n) { 15 | j = 0; 16 | while (j < i) { 17 | k += (i - j); 18 | j++; 19 | } 20 | i++; 21 | } 22 | vtrace(k, n); 23 | //assert(k >= n); 24 | } 25 | 26 | void main(int argc, char *argv[]) { 27 | mainQ(atoi(argv[1])); 28 | } 29 | -------------------------------------------------------------------------------- /benchmark/c/hola/18.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int flag, int j){} 6 | 7 | void mainQ(int flag, int a) { 8 | int b = 0; 9 | int j = 0; 10 | for (b = 0; b < 5; ++b) { 11 | if (flag != 0) j = j + 1; 12 | } 13 | 14 | if (flag !=0){ 15 | vtrace1(flag, j); 16 | } 17 | //if (flag != 0) assert(j == 100); 18 | } 19 | 20 | void main(int argc, char *argv[]) { 21 | mainQ(atoi(argv[1]), atoi(argv[2])); 22 | } 23 | -------------------------------------------------------------------------------- /benchmark/c/hola/19.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int y, int n){} 6 | 7 | 8 | void mainQ(int m, int n) { 9 | vassume(n >= 0); 10 | vassume(m >= 0); 11 | vassume(m < n); 12 | 13 | int x = 0; 14 | int y = m; 15 | 16 | while (x < n) { 17 | x++; 18 | if (x > m) y++; 19 | } 20 | 21 | vtrace(y, n); 22 | //assert(y == n); 23 | } 24 | 25 | void main(int argc, char *argv[]) { 26 | mainQ(atoi(argv[1]), atoi(argv[2])); 27 | } 28 | -------------------------------------------------------------------------------- /benchmark/c/hola/22.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int x, int y, int z){} 6 | 7 | 8 | void mainQ(int u1) { 9 | vassume(u1 > 0); 10 | int x = 0; 11 | int y = 0; 12 | int z = 0; 13 | int k = 0; 14 | int i0 = 0; 15 | 16 | while (i0 < u1) { 17 | i0++; 18 | if (k % 3 == 0) x++; 19 | y++; 20 | z++; 21 | k = x + y + z; 22 | } 23 | 24 | vtrace(x, y, z); 25 | //assert(x == y); 26 | //assert(y == z); 27 | } 28 | 29 | void main(int argc, char *argv[]) { 30 | mainQ(atoi(argv[1])); 31 | } 32 | -------------------------------------------------------------------------------- /benchmark/c/hola/23.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int s){} 6 | 7 | 8 | void mainQ(int i, int n) { 9 | vassume(n >= 0); 10 | int s = 0; 11 | for (i = 0; i < n; ++i) { 12 | s = s + i; 13 | } 14 | 15 | vtrace(s); 16 | //assert(s >= 0); 17 | } 18 | 19 | void main(int argc, char *argv[]) { 20 | mainQ(atoi(argv[1]), atoi(argv[2])); 21 | } 22 | -------------------------------------------------------------------------------- /benchmark/c/hola/24.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int k, int i){} 6 | 7 | void mainQ(int j, int k, int n) { 8 | int i = 0; 9 | 10 | for (i = 0; i < n; i++) { 11 | 12 | for (j = i; j < n; j++) { 13 | 14 | for (k = j; k < n; k++) { 15 | vtrace(k, i); 16 | //assert(k >= i); 17 | } 18 | } 19 | } 20 | //%%%traces: int k, int j, int n, int i 21 | } 22 | 23 | void main(int argc, char *argv[]) { 24 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 25 | } 26 | -------------------------------------------------------------------------------- /benchmark/c/hola/27.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int k){} 6 | 7 | void mainQ(int l, int i, int k, int n) { 8 | vassume(l > 0); 9 | 10 | for (k = 1; k < n; k++) { 11 | 12 | for (i = l; i < n; i++) { 13 | } 14 | 15 | for (i = l; i < n; i++) { 16 | vtrace(k); 17 | //assert(1 <= k); 18 | } 19 | } 20 | } 21 | 22 | void main(int argc, char *argv[]) { 23 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3]), atoi(argv[4])); 24 | } 25 | -------------------------------------------------------------------------------- /benchmark/c/hola/28.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int y, int n){} 6 | 7 | 8 | void mainQ(int u) { 9 | vassume(u > 0); 10 | int x = 0; 11 | int y = 0; 12 | int n = 0; 13 | int i0 = 0; 14 | 15 | while (i0 < u) { 16 | x++; 17 | y++; 18 | i0++; 19 | } 20 | 21 | while (x != n) { 22 | x--; 23 | y--; 24 | } 25 | vtrace(y, n); 26 | //assert(y == n); 27 | } 28 | 29 | void main(int argc, char *argv[]) { 30 | mainQ(atoi(argv[1])); 31 | } 32 | -------------------------------------------------------------------------------- /benchmark/c/hola/30.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void vassume(int b){} 4 | void vtrace(int c){} 5 | 6 | 7 | void mainQ(void) { 8 | int i = 0; 9 | int c = 0; 10 | 11 | while (i < 1000) { 12 | c = c + i; 13 | i = i + 1; 14 | } 15 | 16 | vtrace(c); 17 | //assert(c >= 0); 18 | } 19 | 20 | void main(int argc, char *argv[]) { 21 | mainQ(); 22 | } 23 | -------------------------------------------------------------------------------- /benchmark/c/hola/32.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vtrace(int i, int j){} 5 | 6 | void mainQ(int j) { 7 | int i = j; 8 | int k = 2; 9 | int b = 0; 10 | int n = 0; 11 | for (n = 0; n < 2 * k; n++) { 12 | if (b != 0) { 13 | i++; 14 | b = 0; 15 | } else { 16 | j++; 17 | b = 1; 18 | } 19 | } 20 | //%%%traces: int i, int j, int k, int b, int n 21 | vtrace(i, j); 22 | //assert(i == j); 23 | } 24 | 25 | void main(int argc, char *argv[]) { 26 | mainQ(atoi(argv[1])); 27 | } 28 | -------------------------------------------------------------------------------- /benchmark/c/hola/34.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | void vtrace(int x, int y){} 6 | 7 | void mainQ(int n) { 8 | int x = 0; 9 | int y = 0; 10 | int i = 0; 11 | int m = 10; 12 | 13 | while (i < n) { 14 | i++; 15 | x++; 16 | if (i % 2 == 0) y++; 17 | } 18 | 19 | //manual 20 | 21 | // vtrace(x, y, i, m, n); 22 | if (i == m) { 23 | vtrace(x, y); 24 | // assert(x == 2 * y); */ 25 | } 26 | 27 | } 28 | 29 | void main(int argc, char *argv[]) { 30 | mainQ(atoi(argv[1])); 31 | } 32 | -------------------------------------------------------------------------------- /benchmark/c/hola/35.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vtrace(int x, int n){} 5 | 6 | void mainQ(int n) { 7 | int x = 0; 8 | while (x < n) { 9 | x++; 10 | } 11 | 12 | //%%%traces: int x, int n 13 | 14 | if (n > 0){ 15 | vtrace(x, n); 16 | } 17 | // assert(x == n); 18 | } 19 | 20 | void main(int argc, char *argv[]) { 21 | mainQ(atoi(argv[1])); 22 | } 23 | -------------------------------------------------------------------------------- /benchmark/c/hola/37.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int n, int m){} 6 | 7 | void mainQ(int n, int u1) { 8 | vassume(u1 > 0); 9 | int x = 0; 10 | int m = 0; 11 | 12 | while (x < n) { 13 | if (u1) { 14 | m = x; 15 | } 16 | x = x + 1; 17 | } 18 | 19 | //%%%traces: int n, int m, int x 20 | 21 | if (n > 0) { 22 | vtrace(n, m); 23 | } 24 | //assert(0 <= m && m < n); 25 | } 26 | 27 | void main(int argc, char *argv[]) { 28 | mainQ(atoi(argv[1]), atoi(argv[2])); 29 | } 30 | -------------------------------------------------------------------------------- /benchmark/c/hola/38.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vtrace(int x, int y){} 5 | 6 | void mainQ(int n) { 7 | int x = 0; 8 | int y = 0; 9 | int i = 0; 10 | 11 | while (i < n) { 12 | i++; 13 | x++; 14 | if (i % 2 == 0) y++; 15 | } 16 | //%%%traces: int i, int x, int y 17 | 18 | if (i % 2 == 0) { 19 | vtrace(x, y); 20 | } 21 | //assert(x == 2 * y); 22 | } 23 | 24 | void main(int argc, char *argv[]) { 25 | mainQ(atoi(argv[1])); 26 | } 27 | -------------------------------------------------------------------------------- /benchmark/c/hola/41.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int z, int n){} 6 | 7 | void mainQ(int n, int kt, int flag) { 8 | vassume(n >= 0); 9 | int k = 1; 10 | if (flag != 0) { 11 | vassume(kt >= 0); 12 | k = kt; 13 | } 14 | int i = 0; 15 | int j = 0; 16 | 17 | while (i <= n) { 18 | i++; 19 | j += i; 20 | } 21 | 22 | int z = k + i + j; 23 | //%%%traces: int z, int n, int i, int j 24 | vtrace(z, n); 25 | //assert(z > 2 * n); 26 | } 27 | 28 | void main(int argc, char *argv[]) { 29 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 30 | } 31 | -------------------------------------------------------------------------------- /benchmark/c/hola/43.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int y, int t, int i){} 6 | 7 | void mainQ(int x, int y, int u1) { 8 | vassume(u1 > 0); 9 | vassume(x != y); 10 | 11 | int i = 0; 12 | int t = y; 13 | 14 | while (i < u1) { 15 | i++; 16 | if (x > 0) y = y + x; 17 | } 18 | //%%%traces: int y, int t, int i 19 | vtrace(y, t, i); 20 | //assert(y >= t); 21 | } 22 | 23 | void main(int argc, char *argv[]) { 24 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 25 | } 26 | -------------------------------------------------------------------------------- /benchmark/c/hola/44.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vtrace(int j, int i, int flag){} 5 | 6 | void mainQ(int k, int flag) { 7 | int j = 0; 8 | int n = 0; 9 | 10 | if (flag == 1) { 11 | n = 1; 12 | } else { 13 | n = 2; 14 | } 15 | 16 | int i = 0; 17 | 18 | while (i <= k) { 19 | i++; 20 | j = j + n; 21 | } 22 | 23 | //%%%traces: int j, int i, int k 24 | 25 | if (flag == 1) { 26 | vtrace(j, i, flag); 27 | } 28 | //assert(j == i); 29 | } 30 | 31 | void main(int argc, char *argv[]) { 32 | mainQ(atoi(argv[1]), atoi(argv[2])); 33 | } 34 | -------------------------------------------------------------------------------- /benchmark/c/hola/46.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int x){} 6 | 7 | void mainQ(int u1) { 8 | vassume(u1 > 0); 9 | int w = 1; 10 | int z = 0; 11 | int x = 0; 12 | int y = 0; 13 | int i1 = 0; 14 | while (i1 < u1) { 15 | i1++; 16 | if (w % 2 == 1) { 17 | x++; 18 | w++; 19 | }; 20 | if (z % 2 == 0) { 21 | y++; 22 | z++; 23 | }; 24 | } 25 | //%%%traces: int x, int z, int y, int w 26 | vtrace(x); 27 | //assert(x <= 1); 28 | } 29 | 30 | void main(int argc, char *argv[]) { 31 | mainQ(atoi(argv[1])); 32 | } 33 | -------------------------------------------------------------------------------- /benchmark/c/nla/README.md: -------------------------------------------------------------------------------- 1 | ## Difficult ones 2 | freire1.c 3 | freire2.c 4 | knuth.c 5 | ps1.c 6 | -------------------------------------------------------------------------------- /benchmark/c/nla/cohencu.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vtrace1(int a, int n, int x, int y, int z){} 5 | //void vtrace2(int a, int n, int x, int y, int z){} 6 | 7 | int mainQ(int a){ 8 | int n,x,y,z; 9 | 10 | n=0; x=0; y=1; z=6; 11 | 12 | while(1){ 13 | //assert(z == 6*n + 6); 14 | //assert(y == 3*n*n + 3*n + 1); 15 | //assert(x == n*n*n); 16 | 17 | vtrace1(a, n, x, y, z); 18 | if(!(n<=a)) break; 19 | 20 | n=n+1; 21 | x=x+y; 22 | y=y+z; 23 | z=z+6; 24 | } 25 | //vtrace2(a, n, x, y, z); 26 | return x; 27 | } 28 | 29 | 30 | void main(int argc, char **argv){ 31 | mainQ(atoi(argv[1])); 32 | } 33 | 34 | -------------------------------------------------------------------------------- /benchmark/c/nla/freire1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int mainQ(int a){ 5 | float x = ((double)a)/2.0; 6 | int r = 0; 7 | 8 | 9 | while(1){ 10 | //assert((double)a == 2*x + r*r - r); 11 | //%%%traces: int a, double x, int r 12 | 13 | if (!(x>r)) break; 14 | x = x - r; 15 | r = r + 1; 16 | } 17 | 18 | //assert(r==(int)round(sqrt(a))); 19 | return r; 20 | } 21 | 22 | 23 | int main(int argc, char **argv){ 24 | mainQ(atoi(argv[1])); 25 | return 0; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /benchmark/c/nla/freire2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int mainQ(int a){ 5 | float x,s; 6 | int r; 7 | x = (double)a; 8 | r = 1; 9 | s = 3.25; 10 | 11 | while (1){ 12 | //%%%traces: int a, double x, int r, double s 13 | if(!(x-s > 0.0)) break; 14 | 15 | //assert(((int)(4*r*r*r - 6*r*r + 3*r) + (int)(4*x - 4*a)) == 1); 16 | //assert((int)(4*s) -12*r*r == 1); 17 | 18 | x = x - s; 19 | s = s + 6 * r + 3; 20 | r = r + 1; 21 | } 22 | 23 | return r; 24 | } 25 | 26 | 27 | int main(int argc, char **argv){ 28 | mainQ(atoi(argv[1])); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /benchmark/c/nla/geo2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int x, int y, int z, int k){} 6 | 7 | int mainQ(int z, int k){ 8 | vassume(z>=0); 9 | vassume(z<=10); 10 | vassume(k>0); 11 | vassume(k<=10); 12 | 13 | int x = 1; int y = 1; int c = 1; 14 | 15 | while (1){ 16 | //assert(1+x*z-x-z*y==0); 17 | vtrace1(x, y, z, k); 18 | 19 | if(!(c < k)) break; 20 | c = c + 1; 21 | x = x*z + 1; 22 | y = y*z; 23 | } 24 | return x; 25 | } 26 | 27 | 28 | void main(int argc, char **argv){ 29 | mainQ(atoi(argv[1]), atoi(argv[2])); 30 | 31 | } 32 | 33 | -------------------------------------------------------------------------------- /benchmark/c/nla/geo3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | 6 | void vtrace1(int x, int y, int z, int a, int k){} 7 | 8 | int mainQ(int z, int a, int k){ 9 | vassume(z >= 0); 10 | vassume(z <= 10); 11 | vassume(k > 0); 12 | vassume(k <= 10); 13 | 14 | int x = a; int y = 1; int c = 1; 15 | 16 | while (1){ 17 | //assert(z*x-x+a-a*z*y == 0); 18 | vtrace1(x, y, z, a, k); 19 | 20 | if (!(c < k)) break; 21 | c = c + 1; 22 | x = x*z + a; 23 | y = y*z; 24 | 25 | } 26 | return x; 27 | } 28 | 29 | 30 | void main(int argc, char **argv){ 31 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 32 | } 33 | 34 | -------------------------------------------------------------------------------- /benchmark/c/nla/ps1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int mainQ(int k){ 4 | assert (k>=0); 5 | int y = 0; 6 | int x = 0; 7 | int c = 0; 8 | 9 | while(1){ 10 | //%%%traces: int x, int y, int k 11 | if (!(c < k)) break; 12 | 13 | c = c + 1; 14 | y = y + 1; 15 | x = x + 1; 16 | } 17 | return x; 18 | } 19 | 20 | 21 | 22 | int main(int argc, char **argv){ 23 | mainQ(atoi(argv[1])); 24 | return 0; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /benchmark/c/nla/ps2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int x, int y, int k){} 6 | 7 | int mainQ(int k){ 8 | vassume(k >=0); 9 | vassume(k<=30); 10 | 11 | int y = 0; 12 | int x = 0; 13 | int c = 0; 14 | 15 | 16 | while(1){ 17 | vtrace1(x, y, k); 18 | if (!(c < k)) break; 19 | c = c +1 ; 20 | y=y +1; 21 | x=y+x; 22 | } 23 | return x; 24 | } 25 | 26 | void main(int argc, char **argv){ 27 | mainQ(atoi(argv[1])); 28 | } 29 | 30 | -------------------------------------------------------------------------------- /benchmark/c/nla/ps3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int x, int y, int k){} 6 | 7 | int mainQ(int k){ 8 | 9 | int y = 0; 10 | int x = 0; 11 | int c = 0; 12 | 13 | 14 | while(1){ 15 | //assert(6*x-2*y*y*y-3*y*y-y == 0); 16 | vtrace1(x, y, k); 17 | 18 | if (!(c < k)) break; 19 | c = c +1 ; 20 | y=y +1; 21 | x=y*y+x; 22 | } 23 | return x; 24 | } 25 | 26 | 27 | void main(int argc, char **argv){ 28 | mainQ(atoi(argv[1])); 29 | } 30 | 31 | -------------------------------------------------------------------------------- /benchmark/c/nla/ps4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int x, int y, int k){} 6 | 7 | int mainQ(int k){ 8 | //vassume(k>=0); 9 | //vassume(k<=30); 10 | 11 | int y = 0; 12 | int x = 0; 13 | int c = 0; 14 | 15 | while(1){ 16 | //assert(4*x-(y*y*y*y)-2*(y*y*y)-(y*y) == 0); 17 | vtrace1(x, y, k); 18 | if (!(c < k)) break; 19 | 20 | c = c +1 ; 21 | y=y +1; 22 | x=y*y*y+x; 23 | } 24 | return x; 25 | } 26 | 27 | 28 | void main(int argc, char **argv){ 29 | mainQ(atoi(argv[1])); 30 | } 31 | 32 | -------------------------------------------------------------------------------- /benchmark/c/nla/ps5.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int x, int y, int k){} 6 | 7 | int mainQ(int k){ 8 | vassume(k >= 0); 9 | vassume(k <= 30); //if too large then will cause overflow 10 | 11 | int y = 0; 12 | int x = 0; 13 | int c = 0; 14 | 15 | while(1){ 16 | //assert(6*y*y*y*y*y + 15*y*y*y*y+ 10*y*y*y - 30*x - y == 0); 17 | vtrace1(x, y, k); 18 | if (!(c < k)) break; 19 | c = c +1 ; 20 | y=y +1; 21 | x=y*y*y*y+x; 22 | } 23 | 24 | return x; 25 | } 26 | 27 | void main(int argc, char **argv){ 28 | mainQ(atoi(argv[1])); 29 | } 30 | 31 | -------------------------------------------------------------------------------- /benchmark/c/nla/sqrt1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int a, int n, int t, int s){} 6 | 7 | int mainQ(int n){ 8 | vassume(n >= 0); 9 | 10 | int a,s,t; 11 | a=0; 12 | s=1; 13 | t=1; 14 | 15 | while(1){ 16 | //assert(a*a <= n); 17 | //assert(t == 2*a + 1); 18 | //assert(s == (a + 1)*(a + 1)); 19 | //the above 2 should be equiv to t^2 - 4*s + 2*t + 1 == 0 20 | vtrace1(a, n, t, s); 21 | if(!(s <= n)) break; 22 | a=a+1; 23 | t=t+2; 24 | s=s+t; 25 | } 26 | return a; 27 | 28 | } 29 | 30 | 31 | void main(int argc, char **argv){ 32 | mainQ(atoi(argv[1])); 33 | } 34 | 35 | -------------------------------------------------------------------------------- /benchmark/c/nla_full/README.md: -------------------------------------------------------------------------------- 1 | fermat1.c: TypeError: unsupported operand parent(s) for %: 'Symbolic Ring' and 'Symbolic Ring' 2 | -------------------------------------------------------------------------------- /benchmark/c/nla_full/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dynaroars/dig/7e1ebec4899d7687607e4fdd4c284dd835d68eec/benchmark/c/nla_full/a.out -------------------------------------------------------------------------------- /benchmark/c/nla_full/fail/freire1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int mainQ(int a){ 5 | float x = ((double)a)/2.0; 6 | int r = 0; 7 | 8 | 9 | while(1){ 10 | //assert((double)a == 2*x + r*r - r); 11 | //%%%traces: int a, double x, int r 12 | 13 | if (!(x>r)) break; 14 | x = x - r; 15 | r = r + 1; 16 | } 17 | 18 | //assert(r==(int)round(sqrt(a))); 19 | return r; 20 | } 21 | 22 | 23 | int main(int argc, char **argv){ 24 | mainQ(atoi(argv[1])); 25 | return 0; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /benchmark/c/nla_full/fail/freire2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int mainQ(int a){ 5 | float x,s; 6 | int r; 7 | x = (double)a; 8 | r = 1; 9 | s = 3.25; 10 | 11 | while (1){ 12 | //%%%traces: int a, double x, int r, double s 13 | if(!(x-s > 0.0)) break; 14 | 15 | //assert(((int)(4*r*r*r - 6*r*r + 3*r) + (int)(4*x - 4*a)) == 1); 16 | //assert((int)(4*s) -12*r*r == 1); 17 | 18 | x = x - s; 19 | s = s + 6 * r + 3; 20 | r = r + 1; 21 | } 22 | 23 | return r; 24 | } 25 | 26 | 27 | int main(int argc, char **argv){ 28 | mainQ(atoi(argv[1])); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /benchmark/c/nla_full/fail/ps1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int mainQ(int k){ 4 | assert (k>=0); 5 | int y = 0; 6 | int x = 0; 7 | int c = 0; 8 | 9 | while(1){ 10 | //%%%traces: int x, int y, int k 11 | if (!(c < k)) break; 12 | 13 | c = c + 1; 14 | y = y + 1; 15 | x = x + 1; 16 | } 17 | return x; 18 | } 19 | 20 | 21 | 22 | int main(int argc, char **argv){ 23 | mainQ(atoi(argv[1])); 24 | return 0; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /benchmark/c/nla_full/ps2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int x, int y, int k){} 6 | void vtrace2(int x, int y, int k){} 7 | 8 | int mainQ(int k){ 9 | vassume(k<=30); 10 | 11 | int y = 0; 12 | int x = 0; 13 | int c = 0; 14 | 15 | 16 | while(1){ 17 | //%%%traces: int x, int y, int k 18 | vtrace1(x,y,k); 19 | if (!(c < k)) break; 20 | c = c +1 ; 21 | y=y +1; 22 | x=y+x; 23 | } 24 | vtrace2(x,y,k); 25 | return x; 26 | } 27 | 28 | void main(int argc, char **argv){ 29 | mainQ(atoi(argv[1])); 30 | } 31 | 32 | -------------------------------------------------------------------------------- /benchmark/c/nla_full/ps3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b) {} 5 | void vtrace1(int x, int y, int k) {} 6 | void vtrace2(int x, int y, int k) {} 7 | 8 | int mainQ(int k) 9 | { 10 | 11 | int y = 0; 12 | int x = 0; 13 | int c = 0; 14 | 15 | while (1) 16 | { 17 | // assert(6*x-2*y*y*y-3*y*y-y == 0); 18 | vtrace1(x, y, k); 19 | 20 | if (!(c < k)) 21 | break; 22 | c = c + 1; 23 | y = y + 1; 24 | x = y * y + x; 25 | } 26 | vtrace2(x, y, k); 27 | return x; 28 | } 29 | 30 | void main(int argc, char **argv) 31 | { 32 | mainQ(atoi(argv[1])); 33 | } 34 | -------------------------------------------------------------------------------- /benchmark/c/nla_full/ps4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int x, int y, int k){} 6 | void vtrace2(int x, int y, int k){} 7 | 8 | int mainQ(int k){ 9 | vassume(k<=30); 10 | 11 | int y = 0; 12 | int x = 0; 13 | int c = 0; 14 | 15 | while(1){ 16 | //assert(4*x-(y*y*y*y)-2*(y*y*y)-(y*y) == 0); 17 | vtrace1(x, y, k); 18 | if (!(c < k)) break; 19 | 20 | c = c +1 ; 21 | y=y +1; 22 | x=y*y*y+x; 23 | } 24 | vtrace2(x, y, k); 25 | return x; 26 | } 27 | 28 | 29 | void main(int argc, char **argv){ 30 | mainQ(atoi(argv[1])); 31 | } 32 | 33 | -------------------------------------------------------------------------------- /benchmark/c/nla_full/ps5.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int x, int y, int k){} 6 | void vtrace2(int x, int y, int k){} 7 | 8 | int mainQ(int k){ 9 | vassume(k <= 30); //if too large then will cause overflow 10 | 11 | int y = 0; 12 | int x = 0; 13 | int c = 0; 14 | 15 | while(1){ 16 | //assert(6*y*y*y*y*y + 15*y*y*y*y+ 10*y*y*y - 30*x - y == 0); 17 | vtrace1(x, y, k); 18 | if (!(c < k)) break; 19 | c = c +1 ; 20 | y=y +1; 21 | x=y*y*y*y+x; 22 | } 23 | vtrace2(x, y, k); 24 | return x; 25 | } 26 | 27 | void main(int argc, char **argv){ 28 | mainQ(atoi(argv[1])); 29 | } 30 | 31 | -------------------------------------------------------------------------------- /benchmark/java/complexity/Cav09_Fig1a.java: -------------------------------------------------------------------------------- 1 | public class Cav09_Fig1a { 2 | public static void vtrace_post(int m, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int m){ 5 | int x = 0; 6 | int y = 0; 7 | int tCtr = 0; 8 | while(x < 100){ 9 | if (y < m){ 10 | y++; 11 | } 12 | else{ 13 | x++; 14 | } 15 | tCtr++; 16 | } 17 | vtrace_post(m, tCtr); 18 | //%%%traces: int m, int t 19 | //dig2: m*t - (t*t) - 100*m + 200*t - 10000 == 0 20 | //solve for t: t == m + 100, t == 100 21 | return 0; 22 | } 23 | } 24 | 25 | -------------------------------------------------------------------------------- /benchmark/java/complexity/Cav09_Fig1d.java: -------------------------------------------------------------------------------- 1 | public class Cav09_Fig1d { 2 | public static void vtrace_post(int m, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int m){ 5 | int x = 0; 6 | int y = 0; 7 | int tCtr = 0; 8 | while(x < 100 && y < m){ 9 | y++; 10 | tCtr++; 11 | } 12 | while(x < 100 && y >= m){ 13 | x++; 14 | tCtr++; 15 | } 16 | vtrace_post(m, tCtr); 17 | //%%%traces: int m, int t 18 | //dig2: m*t - (t*t) - 100*m + 200*t - 10000 == 0 19 | //solve for t: t == m + 100, t == 100 20 | return 0; 21 | } 22 | } 23 | 24 | -------------------------------------------------------------------------------- /benchmark/java/complexity/Cav09_Fig3a.java: -------------------------------------------------------------------------------- 1 | public class Cav09_Fig3a { 2 | public static void vtrace_post(int n, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int n){ 5 | int x = 0; 6 | int y = 0; 7 | int tCtr = 0; 8 | while(x < n){ 9 | y = x; 10 | while (y < n){ 11 | tCtr++; 12 | y++; 13 | } 14 | 15 | x=y+1; 16 | } 17 | 18 | vtrace_post(n, tCtr); 19 | //%%%traces: int n, int t 20 | //dig2: n*t - (t*t) == 0, -t <= 0, n - t <= 0 21 | return 0; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /benchmark/java/complexity/Cav09_Fig5b.java: -------------------------------------------------------------------------------- 1 | public class Cav09_Fig5b { 2 | public static void vtrace_post(int a, int n, int y, int x, int tCtr){} 3 | public static void main (String[] args) {} 4 | 5 | public static int mainQ(int a, int n){ 6 | int x = 0; 7 | int y = a; 8 | int tCtr = 0; 9 | while(x < n){ 10 | y++; 11 | x = x + y; 12 | tCtr++; 13 | 14 | } 15 | 16 | //%%%traces: int a, int n, int y, int x, int t 17 | //dig2: (y*y) - (a*a) - 2*x + y - a == 0, -x <= 0, n - x <= 0, t - y + a == 0, -y + a <= 0 18 | vtrace_post(a, n, y, x, tCtr); 19 | 20 | return 0; 21 | } 22 | 23 | } 24 | 25 | -------------------------------------------------------------------------------- /benchmark/java/complexity/PLDI09_Ex6.java: -------------------------------------------------------------------------------- 1 | public class PLDI09_Ex6 { 2 | public static void vtrace_post(int n, int m, int i, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int n, int m){ 5 | assert (0 <= n); 6 | assert (0 <= m); 7 | int i = 0; 8 | int j = 0; 9 | int k = 0; 10 | int tCtr = 0; 11 | 12 | while(i++ < n){ 13 | //note remove if(nondet) 14 | tCtr++; 15 | if (i % 2 !=0){//odd 16 | while(j++ < m){tCtr++;} 17 | } 18 | else{ 19 | while(k++ < m){tCtr++;} 20 | } 21 | } 22 | vtrace_post(n, m, i, tCtr); 23 | return 0; 24 | } 25 | 26 | } 27 | 28 | -------------------------------------------------------------------------------- /benchmark/java/complexity/PLDI09_Fig4_1.java: -------------------------------------------------------------------------------- 1 | public class PLDI09_Fig4_1 { 2 | public static void vtrace_post(int id, int n, int tCtr){} 3 | public static void main (String[] args) { 4 | } 5 | 6 | public static int mainQ(int id, int n){ 7 | assert (id >= 0); 8 | assert (n > id); 9 | int tmp = id + 1; 10 | int tCtr = 0; 11 | 12 | while(tmp != id){ 13 | if (tmp <= n) { 14 | tmp = tmp + 1; 15 | }else{ 16 | tmp=0; 17 | } 18 | tCtr++; 19 | } 20 | vtrace_post(id, n, tCtr); 21 | //dig2: n - t + 1 == 0, -id <= 0, id - n <= -1 22 | return 0; 23 | } 24 | } 25 | 26 | -------------------------------------------------------------------------------- /benchmark/java/complexity/PLDI09_Fig4_3.java: -------------------------------------------------------------------------------- 1 | public class PLDI09_Fig4_3 { 2 | public static void vtrace_post(int n, int m, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int n, int m){ 5 | assert (m > 0); 6 | assert (n > m); 7 | int i = 0; 8 | int j = 0; 9 | int tCtr = 0; 10 | while(i= 0); 8 | int x = 0; 9 | int y = 0; 10 | int tCtr = 0; 11 | while (x < n) { 12 | if (y < m) { 13 | y = y + 1; 14 | } else { 15 | x = x + 1; 16 | } 17 | tCtr++; 18 | } 19 | vtrace_post(n, m, tCtr); 20 | /* 21 | * SymInfer Results 22 | * 1. m*tCtr + n*tCtr - tCtr^2 == 0 23 | * 2. -m <= 0 24 | * 3. -tCtr <= 0 25 | * 4. n - tCtr <= 0 26 | */ 27 | return 0; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /benchmark/java/complexity/POPL09_Fig4_2.java: -------------------------------------------------------------------------------- 1 | public class POPL09_Fig4_2 { 2 | public static void vtrace_post(int n, int m, int a, int b, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int a, int b, int n, int m){ 5 | int x = a; 6 | int y = b; 7 | 8 | int tCtr = 0; 9 | while(x < n){ 10 | while(y < m){ 11 | y = y + 1; 12 | tCtr++; 13 | } 14 | x = x + 1; 15 | tCtr++; 16 | } 17 | vtrace_post(n, m, a, b, tCtr); 18 | // l17: -t <= 0, m*n*t + (n*n)*t - m*(t*t) - 2*n*(t*t) + (t*t*t) - m*t*a - 2*n*t*a + 2*(t*t)*a + t*(a*a) - n*t*b + (t*t)*b + t*a*b == 0 19 | return 0; 20 | } 21 | 22 | } 23 | 24 | -------------------------------------------------------------------------------- /benchmark/java/complexity/tests/PLDI09_Fig4_5.java: -------------------------------------------------------------------------------- 1 | public class PLDI09_Fig4_5 { 2 | public static void vtrace0(int n, int m, int j, int i, int tCtr) {} 3 | public static void main(String[] args) {} 4 | 5 | public static int mainQ(int n, int m, int j) { 6 | assert (m > 0); 7 | assert (n > m); 8 | int i = m; 9 | int tCtr = 0; 10 | while (i > 0 && i < n) { 11 | vtrace0(n, m, j, i, tCtr); 12 | if (j > 0) { 13 | i++; 14 | } else { 15 | i--; 16 | } 17 | tCtr++; 18 | } 19 | return 0; 20 | } 21 | 22 | } 23 | 24 | -------------------------------------------------------------------------------- /benchmark/java/deleteme/Cav09_Fig1d.java: -------------------------------------------------------------------------------- 1 | public class Cav09_Fig1d { 2 | public static void vtrace_post(int m, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int m){ 5 | int x = 0; 6 | int y = 0; 7 | int tCtr = 0; 8 | while(x < 100 && y < m){ 9 | y++; 10 | tCtr++; 11 | } 12 | while(x < 100 && y >= m){ 13 | x++; 14 | tCtr++; 15 | } 16 | vtrace_post(m, tCtr); 17 | //%%%traces: int m, int t 18 | //dig2: m*t - (t*t) - 100*m + 200*t - 10000 == 0 19 | //solve for t: t == m + 100, t == 100 20 | return 0; 21 | } 22 | } 23 | 24 | -------------------------------------------------------------------------------- /benchmark/java/deleteme/Cav09_Fig3a.java: -------------------------------------------------------------------------------- 1 | public class Cav09_Fig3a { 2 | public static void vtrace_post(int n, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int n){ 5 | int x = 0; 6 | int y = 0; 7 | int tCtr = 0; 8 | while(x < n){ 9 | y = x; 10 | while (y < n){ 11 | tCtr++; 12 | y++; 13 | } 14 | 15 | x=y+1; 16 | } 17 | 18 | vtrace_post(n, tCtr); 19 | //%%%traces: int n, int t 20 | //dig2: n*t - (t*t) == 0, -t <= 0, n - t <= 0 21 | return 0; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /benchmark/java/deleteme/Cav09_Fig5b.java: -------------------------------------------------------------------------------- 1 | public class Cav09_Fig5b { 2 | public static void vtrace_post(int a, int n, int y, int x, int tCtr){} 3 | public static void main (String[] args) {} 4 | 5 | public static int mainQ(int a, int n){ 6 | int x = 0; 7 | int y = a; 8 | int tCtr = 0; 9 | while(x < n){ 10 | y++; 11 | x = x + y; 12 | tCtr++; 13 | 14 | } 15 | 16 | //%%%traces: int a, int n, int y, int x, int t 17 | //dig2: (y*y) - (a*a) - 2*x + y - a == 0, -x <= 0, n - x <= 0, t - y + a == 0, -y + a <= 0 18 | vtrace_post(a, n, y, x, tCtr); 19 | 20 | return 0; 21 | } 22 | 23 | } 24 | 25 | -------------------------------------------------------------------------------- /benchmark/java/deleteme/PLDI09_Ex6.java: -------------------------------------------------------------------------------- 1 | public class PLDI09_Ex6 { 2 | public static void vtrace_post(int n, int m, int i, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int n, int m){ 5 | assert (0 <= n); 6 | assert (0 <= m); 7 | int i = 0; 8 | int j = 0; 9 | int k = 0; 10 | int tCtr = 0; 11 | 12 | while(i++ < n){ 13 | //note remove if(nondet) 14 | tCtr++; 15 | if (i % 2 !=0){//odd 16 | while(j++ < m){tCtr++;} 17 | } 18 | else{ 19 | while(k++ < m){tCtr++;} 20 | } 21 | } 22 | vtrace_post(n, m, i, tCtr); 23 | return 0; 24 | } 25 | 26 | } 27 | 28 | -------------------------------------------------------------------------------- /benchmark/java/deleteme/PLDI09_Fig4_1.java: -------------------------------------------------------------------------------- 1 | public class PLDI09_Fig4_1 { 2 | public static void vtrace_post(int id, int n, int tCtr){} 3 | public static void main (String[] args) { 4 | } 5 | 6 | public static int mainQ(int id, int n){ 7 | assert (id >= 0); 8 | assert (n > id); 9 | int tmp = id + 1; 10 | int tCtr = 0; 11 | 12 | while(tmp != id){ 13 | if (tmp <= n) { 14 | tmp = tmp + 1; 15 | }else{ 16 | tmp=0; 17 | } 18 | tCtr++; 19 | } 20 | vtrace_post(id, n, tCtr); 21 | //dig2: n - t + 1 == 0, -id <= 0, id - n <= -1 22 | return 0; 23 | } 24 | } 25 | 26 | -------------------------------------------------------------------------------- /benchmark/java/deleteme/PLDI09_Fig4_3.java: -------------------------------------------------------------------------------- 1 | public class PLDI09_Fig4_3 { 2 | public static void vtrace_post(int n, int m, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int n, int m){ 5 | assert (m > 0); 6 | assert (n > m); 7 | int i = 0; 8 | int j = 0; 9 | int tCtr = 0; 10 | while(i= 0); 8 | int x = 0; 9 | int y = 0; 10 | int tCtr = 0; 11 | while (x < n) { 12 | if (y < m) { 13 | y = y + 1; 14 | } else { 15 | x = x + 1; 16 | } 17 | tCtr++; 18 | } 19 | vtrace_post(n, m, tCtr); 20 | /* 21 | * SymInfer Results 22 | * 1. m*tCtr + n*tCtr - tCtr^2 == 0 23 | * 2. -m <= 0 24 | * 3. -tCtr <= 0 25 | * 4. n - tCtr <= 0 26 | */ 27 | return 0; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /benchmark/java/deleteme/POPL09_Fig4_2.java: -------------------------------------------------------------------------------- 1 | public class POPL09_Fig4_2 { 2 | public static void vtrace_post(int n, int m, int a, int b, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int a, int b, int n, int m){ 5 | int x = a; 6 | int y = b; 7 | 8 | int tCtr = 0; 9 | while(x < n){ 10 | while(y < m){ 11 | y = y + 1; 12 | tCtr++; 13 | } 14 | x = x + 1; 15 | tCtr++; 16 | } 17 | vtrace_post(n, m, a, b, tCtr); 18 | // l17: -t <= 0, m*n*t + (n*n)*t - m*(t*t) - 2*n*(t*t) + (t*t*t) - m*t*a - 2*n*t*a + 2*(t*t)*a + t*(a*a) - n*t*b + (t*t)*b + t*a*b == 0 19 | return 0; 20 | } 21 | 22 | } 23 | 24 | -------------------------------------------------------------------------------- /benchmark/java/hola/H01.java: -------------------------------------------------------------------------------- 1 | public class H01 { 2 | public static void vtrace(int x, int y) { 3 | } 4 | 5 | public static void vtrace1(int y) { 6 | } 7 | 8 | public static void main(String[] args) { 9 | } 10 | 11 | public static void mainQ(int n) { 12 | assert (n > 0); 13 | assert (n <= 30); // will overflow (2^n) without this bound 14 | 15 | int x = 1; 16 | int y = 1; 17 | int j = 0; 18 | int t1 = 0; 19 | int t2 = 0; 20 | while (j < n) { 21 | t1 = x; 22 | t2 = y; 23 | x = t1 + t2; 24 | y = t1 + t2; 25 | j = j + 1; 26 | } 27 | vtrace(x, y); 28 | // vtrace1(y); 29 | // assert(y >= 1); 30 | 31 | } 32 | 33 | } 34 | -------------------------------------------------------------------------------- /benchmark/java/hola/H02.java: -------------------------------------------------------------------------------- 1 | public class H02 { 2 | public static void vtrace(int x, int y){} 3 | public static void main (String[] args){} 4 | 5 | public static void mainQ(int n){ 6 | assert(n > 0); 7 | int i = 1; 8 | int j = 0; 9 | int z = i - j; 10 | int x = 0; 11 | int y = 0; 12 | int w = 0; 13 | int u = 0; 14 | 15 | while (u < n) { 16 | z += x + y + w; 17 | y++; 18 | if (z % 2 == 1) x++; 19 | w += 2; 20 | u = u + 1; 21 | } 22 | vtrace(x, y); 23 | //assert(x == y); 24 | } 25 | } 26 | 27 | -------------------------------------------------------------------------------- /benchmark/java/hola/H03.java: -------------------------------------------------------------------------------- 1 | public class H03 { 2 | 3 | public static void vtrace(int i){} 4 | public static void main (String[] args) {} 5 | 6 | public static void mainQ(int i, int n, int l) { 7 | assert(l > 0); 8 | int t = 0; 9 | int k = 0; 10 | 11 | for (k = 1; k < n; k++) { 12 | 13 | for (i = l; i < n; i++) { 14 | t = t + 1; 15 | } 16 | 17 | for (i = l; i < n; i++) { 18 | 19 | vtrace(i); 20 | // assert(1 <= i) 21 | t = t + 1; 22 | } 23 | } 24 | //%%%traces: int i, int k, int n, int l, int t 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /benchmark/java/hola/H04.java: -------------------------------------------------------------------------------- 1 | public class H04 { 2 | public static void vtrace(int y){} 3 | public static void main (String[] args){} 4 | 5 | public static void mainQ(int y){ 6 | int x = -50; 7 | 8 | while (x < 0) { 9 | x = x + y; 10 | y++; 11 | } 12 | 13 | vtrace(y); 14 | //assert(y > 0); 15 | } 16 | } 17 | 18 | -------------------------------------------------------------------------------- /benchmark/java/hola/H05.java: -------------------------------------------------------------------------------- 1 | public class H05 { 2 | public static void vtrace(int i, int j){} 3 | public static void main (String[] args) {} 4 | 5 | public static void mainQ(int flag, int n){ 6 | assert(n > 0); 7 | int j = 0; 8 | int i = 0; 9 | int x = 0; 10 | int y = 0; 11 | int u = 0; 12 | 13 | while (u < n) { 14 | u++; 15 | x++; 16 | y++; 17 | i += x; 18 | j += y; 19 | if (flag != 0) j += 1; 20 | } 21 | vtrace(i,j); 22 | //assert(j >= i); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /benchmark/java/hola/H06.java: -------------------------------------------------------------------------------- 1 | public class H06 { 2 | public static void vtrace(int x, int y){} 3 | public static void main (String[] args) {} 4 | 5 | public static void mainQ(int n1, int n2) { 6 | int w = 1; 7 | int z = 0; 8 | int x = 0; 9 | int y = 0; 10 | int i1 = 0; 11 | int i2 = 0; 12 | 13 | while (i1 < n1) { 14 | 15 | i2 = 0; 16 | while (i2 < n2) { 17 | 18 | if (w % 2 == 1) x++; 19 | if (z % 2 == 0) y++; 20 | i2++; 21 | } 22 | 23 | z = x + y; 24 | w = z + 1; 25 | i1++; 26 | } 27 | vtrace(x, y); 28 | 29 | //assert(x == y); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /benchmark/java/hola/H07.java: -------------------------------------------------------------------------------- 1 | public class H07 { 2 | public static void vtrace(int a, int b, int n){} 3 | public static void main (String[] args) {} 4 | 5 | public static void mainQ(int n, int u1) { 6 | assert(n >= 0&& u1 > 0); 7 | 8 | int a = 0; 9 | int b = 0; 10 | int i = 0; 11 | int u = 0; 12 | 13 | while (i < n) { 14 | if (u < u1) { 15 | a = a + 1; 16 | b = b + 2; 17 | } else { 18 | a = a + 2; 19 | b = b + 1; 20 | } 21 | i = i + 1; 22 | u++; 23 | } 24 | vtrace(a, b, n); 25 | 26 | //assert(a + b == 3 * n); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /benchmark/java/hola/H10.java: -------------------------------------------------------------------------------- 1 | public class H10 { 2 | public static void vtrace(int x, int y){} 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int u1){ 8 | assert(u1 > 0); 9 | int i1 = 0; 10 | int w = 1; 11 | int z = 0; 12 | int x = 0; 13 | int y = 0; 14 | 15 | while (i1 < u1) { 16 | i1++; 17 | if (w == 1) { 18 | x++; 19 | w = 0; 20 | }; 21 | if (z == 0) { 22 | y++; 23 | z = 1; 24 | }; 25 | } 26 | vtrace(x, y); 27 | //%%%traces: int x, int y, int u1 28 | //assert(x == y); 29 | } 30 | } 31 | 32 | -------------------------------------------------------------------------------- /benchmark/java/hola/H11.java: -------------------------------------------------------------------------------- 1 | public class H11 { 2 | 3 | public static void vtrace(int j, int x, int n){} 4 | public static void main (String[] args) {} 5 | 6 | public static void mainQ(int n){ 7 | int j = 0; 8 | int x = 100; 9 | int i = 0; 10 | 11 | for (i = 0; i < x; i++) { 12 | j = j + 2; 13 | } 14 | 15 | //tvn: need to add input here otherwise lack of traces 16 | vtrace(j, x, n); 17 | //assert(j == 2 * x); 18 | } 19 | 20 | 21 | } 22 | 23 | -------------------------------------------------------------------------------- /benchmark/java/hola/H13.java: -------------------------------------------------------------------------------- 1 | public class H13 { 2 | public static void vtrace(int j, int k){} 3 | public static void main (String[] args) {} 4 | 5 | public static void mainQ(int flag, int u1) { 6 | assert(u1 > 0); 7 | int j = 2; 8 | int k = 0; 9 | int i0 = 0; 10 | 11 | while (i0 < u1) { 12 | i0++; 13 | if (flag != 0) 14 | j = j + 4; 15 | else { 16 | j = j + 2; 17 | k = k + 1; 18 | } 19 | } 20 | if (k !=0) { 21 | vtrace(j, k); 22 | //%%%traces: int j, int k 23 | //if (k != 0) assert(j == 2 * k + 2); 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /benchmark/java/hola/H14.java: -------------------------------------------------------------------------------- 1 | public class H14 { 2 | 3 | public static void vtrace(int a, int m){} 4 | public static void main (String[] args) {} 5 | 6 | public static void mainQ(int m, int u4) { 7 | assert(m > 0); 8 | 9 | int a = 0; 10 | int j = 0; 11 | for (j = 1; j <= m; j++) { 12 | if (u4!=0) 13 | a++; 14 | else 15 | a--; 16 | } 17 | 18 | vtrace(a, m); 19 | //assert(a >= 0 - m); 20 | //assert(a <= m); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /benchmark/java/hola/H15.java: -------------------------------------------------------------------------------- 1 | public class H15 { 2 | 3 | public static void vtrace(int k){} 4 | public static void main (String[] args) {} 5 | 6 | public static void mainQ(int n, int k) { 7 | assert(n > 0); 8 | assert(k > n); 9 | 10 | int j = 0; 11 | while (j < n) { 12 | j++; 13 | k--; 14 | } 15 | 16 | vtrace(k); 17 | //assert(k >= 0); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /benchmark/java/hola/H16.java: -------------------------------------------------------------------------------- 1 | public class H16 { 2 | public static void vtrace(int i, int j, int y){} 3 | public static void main (String[] args) {} 4 | 5 | public static void mainQ(int i, int j) { 6 | int x = i; 7 | int y = j; 8 | 9 | while (x != 0) { 10 | x--; 11 | y--; 12 | } 13 | if (i==j){ 14 | vtrace(i, j, y); 15 | //%%%traces: int i, int j, int y 16 | //if (i == j) assert(y == 0); 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /benchmark/java/hola/H17.java: -------------------------------------------------------------------------------- 1 | public class H17 { 2 | public static void vtrace(int k, int n){} 3 | public static void main (String[] args) {} 4 | 5 | public static void mainQ(int n){ 6 | assert(n > 0); 7 | int k = 1; 8 | int i = 1; 9 | int j = 0; 10 | 11 | while (i < n) { 12 | j = 0; 13 | while (j < i) { 14 | k += (i - j); 15 | j++; 16 | } 17 | i++; 18 | } 19 | 20 | vtrace(k, n); 21 | //assert(k >= n); 22 | 23 | } 24 | } 25 | 26 | -------------------------------------------------------------------------------- /benchmark/java/hola/H18.java: -------------------------------------------------------------------------------- 1 | public class H18 { 2 | public static void vtrace(int flag, int j){} 3 | public static void main (String[] args) {} 4 | 5 | public static void mainQ(int flag, int a) { 6 | int b = 0; 7 | int j = 0; 8 | for (b = 0; b < 100; ++b) { 9 | if (flag != 0) j = j + 1; 10 | } 11 | 12 | vtrace(flag, j); 13 | //if (flag != 0) assert(j == 100); 14 | 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /benchmark/java/hola/H19.java: -------------------------------------------------------------------------------- 1 | public class H19 { 2 | 3 | public static void vtrace(int y, int n){} 4 | public static void main (String[] args) {} 5 | 6 | public static void mainQ(int m, int n) { 7 | assert(n >= 0); 8 | assert(m >= 0); 9 | assert(m < n); 10 | 11 | int x = 0; 12 | int y = m; 13 | 14 | while (x < n) { 15 | x++; 16 | if (x > m) y++; 17 | } 18 | 19 | vtrace(y, n); 20 | //assert(y == n); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /benchmark/java/hola/H20.java: -------------------------------------------------------------------------------- 1 | public class H20 { 2 | 3 | public static void vtrace(int x, int y, int k, int n, int m){} 4 | public static void main (String[] args) {} 5 | 6 | public static void mainQ(int k, int x, int y, int i, int n, int u1) { 7 | assert((x + y) == k); 8 | 9 | int m = 0; 10 | int j = 0; 11 | while (j < n) { 12 | if (j == i) { 13 | x++; 14 | y--; 15 | } else { 16 | y++; 17 | x--; 18 | } 19 | if (u1 != 0) m = j; 20 | j++; 21 | } 22 | vtrace(x, y, k, n, m); 23 | //assert((x + y) == k); 24 | //if (n > 0) { 25 | // assert(0 <= m); 26 | // assert(m < n); 27 | //} 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /benchmark/java/hola/H21.java: -------------------------------------------------------------------------------- 1 | public class H21 { 2 | public static void vtrace(int k, int n){} 3 | public static void main (String[] args) {} 4 | 5 | public static void mainQ(int n, int j, int v, int u4) { 6 | assert(n > 0); 7 | assert(n < 10); 8 | 9 | int c1 = 4000; 10 | int c2 = 2000; 11 | 12 | int k = 0; 13 | int i = 0; 14 | while (i < n) { 15 | i++; 16 | if (u4 !=0) 17 | v = 0; 18 | else 19 | v = 1; 20 | 21 | if (v == 0) 22 | k += c1; 23 | else 24 | k += c2; 25 | } 26 | 27 | //%%%traces: int k, int n, int j, int v 28 | vtrace(k, n); 29 | //assert(k > n); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /benchmark/java/hola/H22.java: -------------------------------------------------------------------------------- 1 | public class H22 { 2 | public static void vtrace(int x, int y, int z){} 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int u1){ 8 | assert(u1 > 0); 9 | int x = 0; 10 | int y = 0; 11 | int z = 0; 12 | int k = 0; 13 | int i0 = 0; 14 | 15 | while (i0 < u1) { 16 | i0++; 17 | if (k % 3 == 0) x++; 18 | y++; 19 | z++; 20 | k = x + y + z; 21 | } 22 | 23 | vtrace(x, y, z); 24 | //assert(x == y); 25 | //assert(y == z); 26 | 27 | } 28 | } 29 | 30 | -------------------------------------------------------------------------------- /benchmark/java/hola/H23.java: -------------------------------------------------------------------------------- 1 | public class H23 { 2 | 3 | public static void vtrace(int s){} 4 | public static void main (String[] args) {} 5 | 6 | public static void mainQ(int i, int n) { 7 | assert(n >= 0); 8 | int s = 0; 9 | for (i = 0; i < n; ++i) { 10 | s = s + i; 11 | } 12 | vtrace(s); 13 | //assert(s >= 0); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /benchmark/java/hola/H24.java: -------------------------------------------------------------------------------- 1 | public class H24 { 2 | public static void vtrace(int k, int i){} 3 | public static void main (String[] args) {} 4 | 5 | public static void mainQ(int j, int k, int n) { 6 | int i = 0; 7 | 8 | for (i = 0; i < n; i++) { 9 | 10 | for (j = i; j < n; j++) { 11 | 12 | for (k = j; k < n; k++) { 13 | vtrace(k, i); 14 | //assert(k >= i); 15 | } 16 | } 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /benchmark/java/hola/H25.java: -------------------------------------------------------------------------------- 1 | public class H25 { 2 | 3 | public static void vtrace(int i, int j){} 4 | 5 | public static void main (String[] args) {} 6 | 7 | public static void mainQ(int u1, int u2) { 8 | int x = 0; 9 | int y = 0; 10 | int i = 0; 11 | int j = 0; 12 | int i1 = 0; 13 | int i2 = 0; 14 | 15 | while (i1 < u1) { 16 | i1++; 17 | i2 = 0; 18 | while (i2 < u2) { 19 | i2++; 20 | if (x == y) 21 | i++; 22 | else 23 | j++; 24 | } 25 | 26 | if (i >= j) { 27 | x++; 28 | y++; 29 | } else 30 | y++; 31 | } 32 | 33 | vtrace(i, j); 34 | //assert(i >= j); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /benchmark/java/hola/H27.java: -------------------------------------------------------------------------------- 1 | public class H27 { 2 | public static void vtrace(int k){} 3 | public static void main (String[] args) {} 4 | 5 | public static void mainQ(int l, int i, int k, int n) { 6 | assert(l > 0); 7 | 8 | for (k = 1; k < n; k++) { 9 | 10 | for (i = l; i < n; i++) { 11 | } 12 | 13 | for (i = l; i < n; i++) { 14 | vtrace(k); 15 | //assert(1 <= k); 16 | } 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /benchmark/java/hola/H28.java: -------------------------------------------------------------------------------- 1 | public class H28 { 2 | public static void vtrace(int y, int n){} 3 | public static void main (String[] args) {} 4 | 5 | public static void mainQ(int u){ 6 | assert(u > 0); 7 | int x = 0; 8 | int y = 0; 9 | int n = 0; 10 | int i0 = 0; 11 | 12 | while (i0 < u) { 13 | x++; 14 | y++; 15 | i0++; 16 | } 17 | 18 | while (x != n) { 19 | x--; 20 | y--; 21 | } 22 | vtrace(y, n); 23 | //assert(y == n); 24 | } 25 | } 26 | 27 | -------------------------------------------------------------------------------- /benchmark/java/hola/H30.java: -------------------------------------------------------------------------------- 1 | 2 | public class H30 { 3 | public static void vtrace(int n, int i, int c){} 4 | 5 | public static void main (String[] args) {} 6 | 7 | public static void mainQ(int n){ 8 | int i = 0; 9 | int c = 0; 10 | 11 | while (i < 1000) { 12 | c = c + i; 13 | i = i + 1; 14 | } 15 | 16 | vtrace(n, i, c); 17 | //assert(c >= 0); 18 | } 19 | 20 | 21 | } 22 | 23 | -------------------------------------------------------------------------------- /benchmark/java/hola/H32.java: -------------------------------------------------------------------------------- 1 | public class H32 { 2 | 3 | public static void vtrace(int i, int j) {} 4 | public static void main (String[] args) { 5 | mainQ(Integer.parseInt(args[0])); 6 | } 7 | 8 | public static void mainQ(int j){ 9 | int i = j; 10 | int k = 100; 11 | int b = 0; 12 | int n = 0; 13 | for (n = 0; n < 2 * k; n++) { 14 | if (b != 0) { 15 | i++; 16 | b = 0; 17 | } else { 18 | j++; 19 | b = 1; 20 | } 21 | } 22 | //%%%traces: int i, int j, int k, int b, int n 23 | vtrace(i, j); 24 | //assert(i == j); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /benchmark/java/hola/H34.java: -------------------------------------------------------------------------------- 1 | public class H34 { 2 | 3 | public static void vtrace(int x, int y, int n, int i, int m) {} 4 | public static void main (String[] args) { 5 | mainQ(Integer.parseInt(args[0])); 6 | } 7 | 8 | public static void mainQ(int n){ 9 | int x = 0; 10 | int y = 0; 11 | int i = 0; 12 | int m = 10; 13 | 14 | while (i < n) { 15 | i++; 16 | x++; 17 | if (i % 2 == 0) y++; 18 | } 19 | //manual 20 | // if (i == m) { 21 | vtrace(x, y, n, i, m); 22 | // // assert(x == 2 * y); 23 | // } 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /benchmark/java/hola/H35.java: -------------------------------------------------------------------------------- 1 | public class H35 { 2 | 3 | public static void vtrace (int x, int n) {} 4 | public static void main (String[] args) { 5 | mainQ(Integer.parseInt(args[0])); 6 | } 7 | 8 | public static void mainQ(int n){ 9 | int x = 0; 10 | while (x < n) { 11 | x++; 12 | } 13 | 14 | //%%%traces: int x, int n 15 | if (n > 0) { 16 | vtrace(x, n); 17 | } 18 | //assert(x == n); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /benchmark/java/hola/H37.java: -------------------------------------------------------------------------------- 1 | public class H37 { 2 | 3 | public static void vtrace(int n, int m) {} 4 | public static void main (String[] args) { 5 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 6 | } 7 | 8 | public static void mainQ(int n, int u1) { 9 | assert(u1 > 0); 10 | int x = 0; 11 | int m = 0; 12 | 13 | while (x < n) { 14 | if (u1 != 0) { 15 | m = x; 16 | } 17 | x = x + 1; 18 | } 19 | 20 | //%%%traces: int n, int m, int x 21 | if (n > 0) { 22 | vtrace(n, m); 23 | } 24 | //assert(0 <= m && m < n); 25 | } 26 | 27 | 28 | } 29 | -------------------------------------------------------------------------------- /benchmark/java/hola/H38.java: -------------------------------------------------------------------------------- 1 | public class H38 { 2 | public static void vtrace(int x, int y){} 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int n){ 8 | int x = 0; 9 | int y = 0; 10 | int i = 0; 11 | 12 | while (i < n) { 13 | i++; 14 | x++; 15 | if (i % 2 == 0) y++; 16 | } 17 | //%%%traces: int i, int x, int y, int n 18 | //vtrace(i, x, y, n); 19 | if (i % 2 == 0){ 20 | vtrace(x,y); 21 | //assert(x == 2 * y); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /benchmark/java/hola/H43.java: -------------------------------------------------------------------------------- 1 | public class H43 { 2 | 3 | public static void vtrace(int y, int t, int i){} 4 | public static void main (String[] args) { 5 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1]), Integer.parseInt(args[2])); 6 | } 7 | 8 | public static void mainQ(int x, int y, int u1) { 9 | assert(u1 > 0); 10 | assert(x != y); 11 | 12 | int i = 0; 13 | int t = y; 14 | 15 | while (i < u1) { 16 | i++; 17 | if (x > 0) y = y + x; 18 | } 19 | //%%%traces: int y, int t, int i 20 | vtrace(y, t, i); 21 | //assert(y >= t); 22 | 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /benchmark/java/hola/H44.java: -------------------------------------------------------------------------------- 1 | public class H44 { 2 | 3 | public static void vtrace(int j, int i, int flag){} 4 | public static void main (String[] args) { 5 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 6 | } 7 | 8 | public static void mainQ(int k, int flag) { 9 | int j = 0; 10 | int n = 0; 11 | 12 | if (flag == 1) { 13 | n = 1; 14 | } else { 15 | n = 2; 16 | } 17 | 18 | int i = 0; 19 | 20 | while (i <= k) { 21 | i++; 22 | j = j + n; 23 | } 24 | 25 | //%%%traces: int j, int i, int k, int flag 26 | 27 | if (flag == 1) { 28 | vtrace(j, i, flag); 29 | //assert(j==i) 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /benchmark/java/hola/H46.java: -------------------------------------------------------------------------------- 1 | public class H46 { 2 | 3 | public static void vtrace(int x){} 4 | public static void main (String[] args) { 5 | mainQ(Integer.parseInt(args[0])); 6 | } 7 | 8 | public static void mainQ(int u1){ 9 | assert(u1 > 0); 10 | int w = 1; 11 | int z = 0; 12 | int x = 0; 13 | int y = 0; 14 | int i1 = 0; 15 | while (i1 < u1) { 16 | i1++; 17 | if (w % 2 == 1) { 18 | x++; 19 | w++; 20 | }; 21 | if (z % 2 == 0) { 22 | y++; 23 | z++; 24 | }; 25 | } 26 | //%%%traces: int x, int z, int y, int w, int u1 27 | vtrace(x); 28 | //assert(x <= 1); 29 | 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /benchmark/java/mp/OddEven2.java: -------------------------------------------------------------------------------- 1 | //swap: a += (b - (b = a)); 2 | public class OddEven2 { 3 | public static void vtrace1(int y0, int y1, int x0, int x1){} 4 | 5 | public static void main (String[] args) {} 6 | 7 | public static void mainQ(int x0, int x1) { 8 | int y0 = x0; 9 | int y1 = x1; 10 | if (y0 >= y1){ 11 | y0 += (y1 - (y1 = y0)); 12 | } 13 | 14 | //assert(y0 <= y1); 15 | vtrace1(y0,y1,x0,x1); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /benchmark/java/mp/PartialIncrement1.java: -------------------------------------------------------------------------------- 1 | public class PartialIncrement1 { 2 | public static void vtrace_loop(int i, int p, int q){} 3 | public static void vtrace_post(int i, int p, int q){} 4 | public static void main (String[] args) {} 5 | 6 | public static void mainQ(int p, int q) { 7 | int i = p; 8 | while(true){ 9 | vtrace_loop(i,p,q); 10 | 11 | if (!(ir)) break; 15 | x = x - r; 16 | r = r + 1; 17 | } 18 | 19 | 20 | return r; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /benchmark/java/nla/Ps2.java: -------------------------------------------------------------------------------- 1 | public class Ps2 { 2 | public static void vtrace1(int x, int y, int k){} 3 | //public static void vtrace2(int x, int y, int k){} 4 | 5 | public static void main (String[] args) {} 6 | public static int mainQ(int k){ 7 | assert (k>=0); 8 | assert (k<=30); 9 | 10 | int y = 0; 11 | int x = 0; 12 | int c = 0; 13 | 14 | while(true){ 15 | //assert((y*y) - 2*x + y == 0); 16 | vtrace1(x,y,k); 17 | if (!(c < k)) break; 18 | c = c +1 ; 19 | y=y +1; 20 | x=y+x; 21 | } 22 | 23 | //vtrace2(x,y,k); 24 | return x; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /benchmark/java/nla/Ps3.java: -------------------------------------------------------------------------------- 1 | public class Ps3 { 2 | public static void vtrace1(int x, int y, int k){} 3 | //public static void vtrace2(int x, int y, int k){} 4 | public static void main (String[] args) {} 5 | public static int mainQ(int k){ 6 | assert (k>=0); 7 | assert (k<=30); 8 | 9 | int y = 0; 10 | int x = 0; 11 | int c = 0; 12 | while(true){ 13 | //assert(6*x-2*y*y*y-3*y*y-y == 0); 14 | vtrace1(x, y, k); 15 | if (!(c < k)) break; 16 | c = c +1 ; 17 | y=y +1; 18 | x=y*y+x; 19 | } 20 | 21 | //assert(6*x-2*y*y*y-3*y*y-y == 0); 22 | //vtrace2(x,y,k); 23 | return x; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /benchmark/java/nla/Ps4.java: -------------------------------------------------------------------------------- 1 | public class Ps4 { 2 | public static void vtrace1(int x, int y, int k){} 3 | //public static void vtrace2(int x, int y, int k){} 4 | public static void main (String[] args) {} 5 | public static int mainQ(int k){ 6 | assert (k>=0); 7 | assert (k<=30); 8 | 9 | int y = 0; 10 | int x = 0; 11 | int c = 0; 12 | 13 | while(true){ 14 | //assert(4*x-(y*y*y*y)-2*(y*y*y)-(y*y) == 0); 15 | vtrace1(x,y,k); 16 | if (!(c < k)) break; 17 | 18 | c = c +1 ; 19 | y=y +1; 20 | x=y*y*y+x; 21 | } 22 | 23 | //assert(4*x-(y*y*y*y)-2*(y*y*y)-(y*y) == 0); 24 | //vtrace2(x,y,k); 25 | return x; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /benchmark/java/nla/fail/Freire1.java: -------------------------------------------------------------------------------- 1 | public class Freire1 { 2 | public static void vtrace1(float a, float x, float r){} 3 | public static void vtrace2(float a, float x, float r){} 4 | 5 | public static void main (String[] args) { 6 | } 7 | 8 | public static void mainQ(float a) { 9 | float x = a/2.0f; 10 | float r = 0; 11 | 12 | while(true){ 13 | vtrace1(a,x,r); 14 | //assert((float)a == 2*x + r*r - r); 15 | if (!(x>r)) break; 16 | x = x - r; 17 | r = r + 1; 18 | } 19 | 20 | vtrace2(a,x,r); 21 | //assert((float)a == 2*x + r*r - r); 22 | //return r; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /benchmark/java/nla/fail/Ps1.java: -------------------------------------------------------------------------------- 1 | public class Ps1 { 2 | public static void vtrace1(int x, int y, int k){} 3 | //public static void vtrace2(int x, int y, int k){} 4 | public static void main (String[] args){} 5 | 6 | public static int mainQ(int k){ 7 | assert (k>=0); 8 | int y = 0; 9 | int x = 0; 10 | int c = 0; 11 | 12 | while(true){ 13 | vtrace1(x, y, k); 14 | if (!(c < k)) break; 15 | 16 | c = c + 1; 17 | y = y + 1; 18 | x = x + 1; 19 | } 20 | //vtrace2(x,y,k); 21 | return x; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /benchmark/java/nla_full/Freire1_Int.java: -------------------------------------------------------------------------------- 1 | public class Freire1_Int { 2 | public static void vtrace1(int a, int x, int r){} 3 | public static void vtrace2(int a, int x, int r){} 4 | 5 | public static void main (String[] args) { 6 | } 7 | 8 | public static void mainQ(int x) { 9 | int a = x * 2; 10 | int r = 0; 11 | 12 | while(true){ 13 | vtrace1(a,x,r); 14 | //assert((int)a == 2*x + r*r - r); 15 | if (!(x>r)) break; 16 | x = x - r; 17 | r = r + 1; 18 | } 19 | 20 | vtrace2(a,x,r); 21 | //assert((int)a == 2*x + r*r - r); 22 | //return r; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /benchmark/java/nla_full/Ps1.java: -------------------------------------------------------------------------------- 1 | public class Ps1 { 2 | public static void vtrace1(int x, int y, int k){} 3 | public static void vtrace2(int x, int y, int k){} 4 | public static void main (String[] args){} 5 | 6 | public static int mainQ(int k){ 7 | assert (k>=0); 8 | int y = 0; 9 | int x = 0; 10 | int c = 0; 11 | 12 | while(true){ 13 | vtrace1(x, y, k); 14 | if (!(c < k)) break; 15 | 16 | c = c + 1; 17 | y = y + 1; 18 | x = x + 1; 19 | } 20 | vtrace2(x,y,k); 21 | return x; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /benchmark/java/nla_full/Ps2.java: -------------------------------------------------------------------------------- 1 | public class Ps2 { 2 | public static void vtrace1(int x, int y, int k){} 3 | public static void vtrace2(int x, int y, int k){} 4 | 5 | public static void main (String[] args) {} 6 | public static int mainQ(int k){ 7 | assert (k>=0); 8 | assert (k<=30); 9 | 10 | int y = 0; 11 | int x = 0; 12 | int c = 0; 13 | 14 | while(true){ 15 | //assert((y*y) - 2*x + y == 0); 16 | vtrace1(x,y,k); 17 | if (!(c < k)) break; 18 | c = c +1 ; 19 | y=y +1; 20 | x=y+x; 21 | } 22 | 23 | vtrace2(x,y,k); 24 | return x; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /benchmark/java/nla_full/Ps3.java: -------------------------------------------------------------------------------- 1 | public class Ps3 { 2 | public static void vtrace1(int x, int y, int k){} 3 | public static void vtrace2(int x, int y, int k){} 4 | public static void main (String[] args) {} 5 | public static int mainQ(int k){ 6 | assert (k>=0); 7 | assert (k<=30); 8 | 9 | int y = 0; 10 | int x = 0; 11 | int c = 0; 12 | while(true){ 13 | //assert(6*x-2*y*y*y-3*y*y-y == 0); 14 | vtrace1(x, y, k); 15 | if (!(c < k)) break; 16 | c = c +1 ; 17 | y=y +1; 18 | x=y*y+x; 19 | } 20 | 21 | //assert(6*x-2*y*y*y-3*y*y-y == 0); 22 | vtrace2(x,y,k); 23 | return x; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /benchmark/java/nla_full/Ps4.java: -------------------------------------------------------------------------------- 1 | public class Ps4 { 2 | public static void vtrace1(int x, int y, int k){} 3 | public static void vtrace2(int x, int y, int k){} 4 | public static void main (String[] args) {} 5 | public static int mainQ(int k){ 6 | assert (k>=0); 7 | assert (k<=30); 8 | 9 | int y = 0; 10 | int x = 0; 11 | int c = 0; 12 | 13 | while(true){ 14 | //assert(4*x-(y*y*y*y)-2*(y*y*y)-(y*y) == 0); 15 | vtrace1(x,y,k); 16 | if (!(c < k)) break; 17 | 18 | c = c +1 ; 19 | y=y +1; 20 | x=y*y*y+x; 21 | } 22 | 23 | //assert(4*x-(y*y*y*y)-2*(y*y*y)-(y*y) == 0); 24 | vtrace2(x,y,k); 25 | return x; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /benchmark/java/nla_full/examples/CohenDiv1Loc.java: -------------------------------------------------------------------------------- 1 | public class CohenDiv1Loc { 2 | public static void vtrace1(int q, int r, int a, int b, int x, int y){} 3 | public static void main (String[] args) {} 4 | 5 | public static int mainQ(int x, int y) { 6 | assert(x>0 && y>0); 7 | 8 | int q=0; 9 | int r=x; 10 | int a=0; 11 | int b=0; 12 | 13 | while(true) { 14 | if(!(r>=y)) break; 15 | a=1; 16 | b=y; 17 | 18 | while (true) { 19 | vtrace1(q,r,a,b,x,y); 20 | if(!(r >= 2*b)) break; 21 | 22 | a = 2*a; 23 | b = 2*b; 24 | } 25 | r=r-b; 26 | q=q+a; 27 | } 28 | 29 | return q; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /benchmark/java/nla_full/examples/Sqrt11Loc.java: -------------------------------------------------------------------------------- 1 | public class Sqrt11Loc { 2 | public static void vtrace1(int a, int n, int t, int s){} 3 | public static void main (String[] args) {} 4 | 5 | public static int mainQ(int n){ 6 | //for a to be sqrt of n, needs to assume that n >= 0 7 | //assert(n >= 0); 8 | 9 | int a,s,t; 10 | a=0; 11 | s=1; 12 | t=1; 13 | 14 | int ctr = 0; 15 | while(true){ 16 | //assert(t == 2*a + 1); 17 | //assert(s == (a + 1)*(a + 1)); 18 | //assert(4s == t*t + 2*t + 1); 19 | vtrace1(a, n, t, s); 20 | if(!(s <= n)) break; 21 | a=a+1; 22 | t=t+2; 23 | s=s+t; 24 | } 25 | return a; 26 | 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /benchmark/java/nla_full/examples/Test1.java: -------------------------------------------------------------------------------- 1 | public class Test1 { 2 | public static void vtrace1(int x, int y, int z, int b, int c){} 3 | public static void main (String[] args){} 4 | 5 | public static int mainQ(int x){ 6 | int y = 0; 7 | int z = 0; 8 | int c = 0; 9 | int b = 0; 10 | 11 | while(true){ 12 | vtrace1(x, y, z, b, c); 13 | if (!(c < x)) break; 14 | 15 | c = c + 1; 16 | y = y + 1; 17 | if (x == 7) z = z+1; 18 | z = z + 1; 19 | } 20 | return x; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /benchmark/java/nla_full/examples/Test4.java: -------------------------------------------------------------------------------- 1 | public class Test4 { 2 | public static void vtrace1(int x, int y, int t){} 3 | 4 | public static void main (String[] args) {} 5 | 6 | public static int mainQ_Test4(int x, int y) { 7 | assert(x>0 && y>0); 8 | int i = 0; 9 | int j = 0; 10 | int t = 0; 11 | while (i < x){ 12 | i++; 13 | // t++; 14 | 15 | while (j < y){ 16 | j++; 17 | t++; 18 | } 19 | j = 0 ; 20 | } 21 | 22 | vtrace1(x,y,t); 23 | return 0; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /benchmark/java/nla_full/examples/benchmark_test/CohenDiv1Loc.java: -------------------------------------------------------------------------------- 1 | public class CohenDiv1Loc { 2 | public static void vtrace1(int q, int r, int a, int b, int x, int y){} 3 | public static void main (String[] args) {} 4 | 5 | public static int mainQ(int x, int y) { 6 | assert(x>0 && y>0); 7 | 8 | int q=0; 9 | int r=x; 10 | int a=0; 11 | int b=0; 12 | 13 | while(true) { 14 | if(!(r>=y)) break; 15 | a=1; 16 | b=y; 17 | 18 | while (true) { 19 | vtrace1(q,r,a,b,x,y); 20 | if(!(r >= 2*b)) break; 21 | 22 | a = 2*a; 23 | b = 2*b; 24 | } 25 | r=r-b; 26 | q=q+a; 27 | } 28 | 29 | return q; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /benchmark/java/nla_full/fail/Freire1.java: -------------------------------------------------------------------------------- 1 | public class Freire1 { 2 | public static void vtrace1(float a, float x, float r){} 3 | public static void vtrace2(float a, float x, float r){} 4 | 5 | public static void main (String[] args) { 6 | } 7 | 8 | public static void mainQ(float a) { 9 | float x = a/2.0f; 10 | float r = 0; 11 | 12 | while(true){ 13 | vtrace1(a,x,r); 14 | //assert((float)a == 2*x + r*r - r); 15 | if (!(x>r)) break; 16 | x = x - r; 17 | r = r + 1; 18 | } 19 | 20 | vtrace2(a,x,r); 21 | //assert((float)a == 2*x + r*r - r); 22 | //return r; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/README: -------------------------------------------------------------------------------- 1 | fig 2.1 popl 2 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_cav09/Fig1a.java: -------------------------------------------------------------------------------- 1 | public class Fig1a { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static int mainQ(int m){ 8 | 9 | int x = 0; 10 | int y = 0; 11 | int t = 0; 12 | while(x < 100){ 13 | if (y < m){ 14 | y++; 15 | } 16 | else{ 17 | x++; 18 | } 19 | t++; 20 | } 21 | 22 | //%%%traces: int m, int t 23 | //dig2: m*t - (t*t) - 100*m + 200*t - 10000 == 0 24 | //solve for t: t == m + 100, t == 100 25 | return 0; 26 | } 27 | } 28 | 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_cav09/Fig1d.java: -------------------------------------------------------------------------------- 1 | public class Fig1d { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static int mainQ(int m){ 8 | int x = 0; 9 | int y = 0; 10 | int t = 0; 11 | while(x < 100 && y < m){ 12 | y++; 13 | t++; 14 | } 15 | while(x < 100 && y >= m){ 16 | x++; 17 | t++; 18 | } 19 | 20 | //%%%traces: int m, int t 21 | //dig2: m*t - (t*t) - 100*m + 200*t - 10000 == 0 22 | //solve for t: t == m + 100, t == 100 23 | return 0; 24 | } 25 | } 26 | 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_cav09/Fig3a.java: -------------------------------------------------------------------------------- 1 | public class Fig3a { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static int mainQ(int n){ 8 | int x = 0; 9 | int y = 0; 10 | int t = 0; 11 | while(x < n){ 12 | y = x; 13 | while (y < n){ 14 | t++; 15 | y++; 16 | } 17 | 18 | x=y+1; 19 | } 20 | //%%%traces: int n, int t 21 | //dig2: n*t - (t*t) == 0, -t <= 0, n - t <= 0 22 | return 0; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_cav09/Fig5b.java: -------------------------------------------------------------------------------- 1 | public class Fig5b { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static int mainQ(int y0, int n){ 8 | int x = 0; 9 | int y = y0; 10 | int t = 0; 11 | while(x < n){ 12 | y++; 13 | x = x + y; 14 | t++; 15 | 16 | } 17 | 18 | //%%%traces: int y0, int n, int y, int x, int t 19 | //dig2: (y*y) - (y0*y0) - 2*x + y - y0 == 0, -x <= 0, n - x <= 0, t - y + y0 == 0, -y + y0 <= 0 20 | 21 | return 0; 22 | } 23 | 24 | } 25 | 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_cav09/fig1a.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int mainQ(int m){ 5 | 6 | int x = 0; 7 | int y = 0; 8 | int t = 0; 9 | while(x < 100){ 10 | if (y < m){ 11 | y++; 12 | } 13 | else{ 14 | x++; 15 | } 16 | t++; 17 | } 18 | 19 | //%%%traces: int m, int t 20 | //dig2: m*t - (t*t) - 100*m + 200*t - 10000 == 0 21 | //solve for t: t == m + 100, t == 100 22 | return 0; 23 | } 24 | 25 | 26 | int main(int argc, char **argv){ 27 | mainQ(atoi(argv[1])); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_cav09/fig1d.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int mainQ(int m){ 5 | 6 | int x = 0; 7 | int y = 0; 8 | int t = 0; 9 | while(x < 100 && y < m){ 10 | y++; 11 | t++; 12 | } 13 | while(x < 100 && y >= m){ 14 | x++; 15 | t++; 16 | } 17 | 18 | //%%%traces: int m, int t 19 | //dig2: m*t - (t*t) - 100*m + 200*t - 10000 == 0 20 | //solve for t: t == m + 100, t == 100 21 | return 0; 22 | } 23 | 24 | 25 | int main(int argc, char **argv){ 26 | mainQ(atoi(argv[1])); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_cav09/fig2a.c: -------------------------------------------------------------------------------- 1 | /*same as Fig 4_3 Gulwani pldi 09*/ 2 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_cav09/fig3a.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | int mainQ(int n){ 7 | int x = 0; 8 | int y = 0; 9 | int t = 0; 10 | while(x < n){ 11 | y = x; 12 | while (y < n){ 13 | t++; 14 | y++; 15 | } 16 | 17 | x=y+1; 18 | } 19 | //%%%traces: int n, int t 20 | //dig2: n*t - (t*t) == 0, -t <= 0, n - t <= 0 21 | return 0; 22 | } 23 | 24 | 25 | int main(int argc, char **argv){ 26 | mainQ(atoi(argv[1])); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_cav09/fig5b.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int mainQ(int y0, int n){ 5 | int x = 0; 6 | int y = y0; 7 | int t = 0; 8 | while(x < n){ 9 | y++; 10 | x = x + y; 11 | t++; 12 | 13 | } 14 | 15 | //%%%traces: int y0, int n, int y, int x, int t 16 | //dig2: (y*y) - (y0*y0) - 2*x + y - y0 == 0, -x <= 0, n - x <= 0, t - y + y0 == 0, -y + y0 <= 0 17 | 18 | return 0; 19 | } 20 | 21 | 22 | int main(int argc, char **argv){ 23 | mainQ(atoi(argv[1]), atoi(argv[2])); 24 | return 0; 25 | } 26 | /*same as Fig 4_3 Gulwani pldi 09*/ 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_pldi09/Fig4_1.java: -------------------------------------------------------------------------------- 1 | public class Fig4_1 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static int mainQ(int id, int n){ 8 | assert (id >= 0); 9 | assert (n > id); 10 | int tmp = id + 1; 11 | int t = 0; 12 | 13 | while(tmp != id){ 14 | if (tmp <= n) { 15 | tmp = tmp + 1; 16 | }else{ 17 | tmp=0; 18 | } 19 | t++; 20 | } 21 | //%%%traces: int id, int n, int t 22 | //dig2: n - t + 1 == 0, -id <= 0, id - n <= -1 23 | return 0; 24 | } 25 | } 26 | 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_pldi09/Fig4_3.java: -------------------------------------------------------------------------------- 1 | public class Fig4_3 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static int mainQ(int n, int m){ 8 | assert (m > 0); 9 | assert (n > m); 10 | int i = 0; 11 | int j = 0; 12 | int t = 0; 13 | while(i 2 | #include 3 | 4 | 5 | int mainQ(int id, int n){ 6 | assert (id >= 0); 7 | assert (n > id); 8 | int tmp = id + 1; 9 | int t = 0; 10 | 11 | while(tmp != id){ 12 | if (tmp <= n) { 13 | tmp = tmp + 1; 14 | }else{ 15 | tmp=0; 16 | } 17 | t++; 18 | } 19 | //%%%traces: int id, int n, int t 20 | //dig2: n - t + 1 == 0, -id <= 0, id - n <= -1 21 | return 0; 22 | } 23 | 24 | 25 | int main(int argc, char **argv){ 26 | mainQ(atoi(argv[1]), atoi(argv[2])); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/complexity/gulwani_pldi09/fig4_3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | //same as fig2a gulwani_cav09 4 | 5 | 6 | int mainQ(int n, int m){ 7 | assert (m > 0); 8 | assert (n > m); 9 | int i = 0; 10 | int j = 0; 11 | int t = 0; 12 | while(i 2 | #include 3 | 4 | int mainQ(int n, int m){ 5 | assert(m>=0); 6 | int x = 0; 7 | int y = 0; 8 | int t = 0; 9 | while(x < n){ 10 | if(y < m){ 11 | y = y + 1; 12 | } 13 | else{ 14 | x = x + 1; 15 | } 16 | t++; 17 | } 18 | //%%%traces: int n, int m, int t 19 | //dig2:n - t <= 0, -t <= 0 nothing useful ?? 20 | //NOTE: should we expect t = something here ? 21 | return 0; 22 | } 23 | 24 | 25 | int main(int argc, char **argv){ 26 | mainQ(atoi(argv[1]), atoi(argv[2])); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/01.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | assert(n>0); 7 | int x = 1; 8 | int y = 1; 9 | int j = 0; 10 | 11 | while (j < n) { 12 | int t1 = x; 13 | int t2 = y; 14 | x = t1 + t2; 15 | y = t1 + t2; 16 | j = j + 1; 17 | } 18 | //%%%traces: int x, int y 19 | 20 | //assert(y >= 1); 21 | } 22 | 23 | int main(int argc, char *argv[]) { 24 | mainQ(atoi(argv[1])); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/02.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | assert (n > 0); 7 | int i = 1; 8 | int j = 0; 9 | int z = i - j; 10 | int x = 0; 11 | int y = 0; 12 | int w = 0; 13 | int u = 0; 14 | 15 | while (u < n) { 16 | z += x + y + w; 17 | y++; 18 | if (z % 2 == 1) x++; 19 | w += 2; 20 | u = u + 1; 21 | } 22 | 23 | //%%%traces: int x, int y 24 | //assert(x == y); 25 | } 26 | 27 | int main(int argc, char *argv[]) { 28 | mainQ(atoi(argv[1])); 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/03.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int i, int n, int l) { 6 | assert(l > 0); 7 | int t = 0; 8 | int k = 0; 9 | 10 | for (k = 1; k < n; k++) { 11 | 12 | for (i = l; i < n; i++) { 13 | t = t + 1; 14 | } 15 | 16 | for (i = l; i < n; i++) { 17 | t = t + 1; 18 | } 19 | } 20 | //%%%traces: int i, int k, int n, int l, int t 21 | } 22 | 23 | int main(int argc, char *argv[]) { 24 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/04.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int y) { 6 | int x = -50; 7 | 8 | while (x < 0) { 9 | x = x + y; 10 | y++; 11 | } 12 | 13 | //%%%traces: int x, int y 14 | //assert(y > 0); 15 | } 16 | 17 | int main(int argc, char *argv[]) { 18 | mainQ(atoi(argv[1])); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/05.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int flag, int n) { 6 | assert(n > 0); 7 | int j = 0; 8 | int i = 0; 9 | int x = 0; 10 | int y = 0; 11 | int u = 0; 12 | 13 | while (u < n) { 14 | u++; 15 | x++; 16 | y++; 17 | i += x; 18 | j += y; 19 | if (flag != 0) j += 1; 20 | } 21 | //%%%traces: int i, int j 22 | 23 | //assert(j >= i); 24 | } 25 | 26 | int main(int argc, char *argv[]) { 27 | mainQ(atoi(argv[1]), atoi(argv[2])); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/06.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n1, int n2) { 6 | int w = 1; 7 | int z = 0; 8 | int x = 0; 9 | int y = 0; 10 | int i1 = 0; 11 | int i2 = 0; 12 | 13 | while (i1 < n1) { 14 | 15 | i2 = 0; 16 | while (i2 < n2) { 17 | 18 | if (w % 2 == 1) x++; 19 | if (z % 2 == 0) y++; 20 | i2++; 21 | } 22 | 23 | z = x + y; 24 | w = z + 1; 25 | i1++; 26 | } 27 | //%%%traces: int x, int y 28 | 29 | //assert(x == y); 30 | } 31 | 32 | int main(int argc, char *argv[]) { 33 | mainQ(atoi(argv[1]), atoi(argv[2])); 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/07.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n, int u1) { 6 | assert(n >= 0&& u1 > 0); 7 | 8 | int a = 0; 9 | int b = 0; 10 | int i = 0; 11 | int u = 0; 12 | 13 | while (i < n) { 14 | if (u < u1) { 15 | a = a + 1; 16 | b = b + 2; 17 | } else { 18 | a = a + 2; 19 | b = b + 1; 20 | } 21 | i = i + 1; 22 | u++; 23 | } 24 | //%%%traces: int a, int b, int n 25 | 26 | //assert(a + b == 3 * n); 27 | } 28 | 29 | int main(int argc, char *argv[]) { 30 | mainQ(atoi(argv[1]), atoi(argv[2])); 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/10.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int u1) { 6 | assert(u1 > 0); 7 | int i1 = 0; 8 | int w = 1; 9 | int z = 0; 10 | int x = 0; 11 | int y = 0; 12 | 13 | while (i1 < u1) { 14 | i1++; 15 | if (w == 1) { 16 | x++; 17 | w = 0; 18 | }; 19 | if (z == 0) { 20 | y++; 21 | z = 1; 22 | }; 23 | } 24 | 25 | //%%%traces: int x, int y 26 | //assert(x == y); 27 | } 28 | 29 | int main(int argc, char *argv[]) { 30 | mainQ(atoi(argv[1])); 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/11.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(void) { 6 | int j = 0; 7 | int x = 100; 8 | int i = 0; 9 | 10 | for (i = 0; i < x; i++) { 11 | j = j + 2; 12 | } 13 | //%%%traces: int j, int x, int i 14 | //assert(j == 2 * x); 15 | } 16 | 17 | int main(int argc, char *argv[]) { 18 | mainQ(); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/13.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int flag, int u1) { 6 | assert(u1 > 0); 7 | int j = 2; 8 | int k = 0; 9 | int i0 = 0; 10 | 11 | while (i0 < u1) { 12 | i0++; 13 | if (flag != 0) 14 | j = j + 4; 15 | else { 16 | j = j + 2; 17 | k = k + 1; 18 | } 19 | } 20 | 21 | //%%%traces: int j, int k 22 | //if (k != 0) assert(j == 2 * k + 2); 23 | } 24 | 25 | int main(int argc, char *argv[]) { 26 | mainQ(atoi(argv[1]), atoi(argv[2])); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/14.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int m, int u4) { 6 | assert(m > 0); 7 | 8 | int a = 0; 9 | int j = 0; 10 | for (j = 1; j <= m; j++) { 11 | if (u4) 12 | a++; 13 | else 14 | a--; 15 | } 16 | 17 | //%%%traces: int a, int m 18 | //assert(a >= 0 - m); 19 | //assert(a <= m); 20 | } 21 | 22 | int main(int argc, char *argv[]) { 23 | mainQ(atoi(argv[1]), atoi(argv[2])); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/15.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n, int k) { 6 | assert(n > 0); 7 | assert(k > n); 8 | 9 | int j = 0; 10 | while (j < n) { 11 | j++; 12 | k--; 13 | } 14 | //%%%traces: int k, int n 15 | //assert(k >= 0); 16 | } 17 | 18 | int main(int argc, char *argv[]) { 19 | mainQ(atoi(argv[1]), atoi(argv[2])); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/16.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int i, int j) { 6 | int x = i; 7 | int y = j; 8 | 9 | while (x != 0) { 10 | x--; 11 | y--; 12 | } 13 | //%%%traces: int i, int j, int y 14 | //if (i == j) assert(y == 0); 15 | } 16 | 17 | int main(int argc, char *argv[]) { 18 | mainQ(atoi(argv[1]), atoi(argv[2])); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/17.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | assert(n > 0); 7 | int k = 1; 8 | int i = 1; 9 | int j = 0; 10 | 11 | while (i < n) { 12 | j = 0; 13 | while (j < i) { 14 | k += (i - j); 15 | j++; 16 | } 17 | i++; 18 | } 19 | //%%%traces: int k, int n 20 | //assert(k >= n); 21 | } 22 | 23 | int main(int argc, char *argv[]) { 24 | mainQ(atoi(argv[1])); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/18.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int a, int b, int flag) { 6 | int j = 0; 7 | for (b = 0; b < 100; ++b) { 8 | if (flag != 0) j = j + 1; 9 | } 10 | 11 | //%%%traces: int j, int flag, int a, int b 12 | //if (flag != 0) assert(j == 100); 13 | } 14 | 15 | int main(int argc, char *argv[]) { 16 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/19.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int m, int n) { 6 | assert(n >= 0); 7 | assert(m >= 0); 8 | assert(m < n); 9 | 10 | int x = 0; 11 | int y = m; 12 | 13 | while (x < n) { 14 | x++; 15 | if (x > m) y++; 16 | } 17 | 18 | //%%%traces: int y, int n 19 | //assert(y == n); 20 | } 21 | 22 | int main(int argc, char *argv[]) { 23 | mainQ(atoi(argv[1]), atoi(argv[2])); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/22.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int u1) { 6 | assert(u1 > 0); 7 | int x = 0; 8 | int y = 0; 9 | int z = 0; 10 | int k = 0; 11 | int i0 = 0; 12 | 13 | while (i0 < u1) { 14 | i0++; 15 | if (k % 3 == 0) x++; 16 | y++; 17 | z++; 18 | k = x + y + z; 19 | } 20 | 21 | //%%%traces: int x, int y, int z 22 | //assert(x == y); 23 | //assert(y == z); 24 | } 25 | 26 | int main(int argc, char *argv[]) { 27 | mainQ(atoi(argv[1])); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/23.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int i, int n) { 6 | assert(n >= 0); 7 | int sum = 0; 8 | for (i = 0; i < n; ++i) { 9 | sum = sum + i; 10 | } 11 | 12 | //%%%traces: int sum, int i, int n 13 | //assert(sum >= 0); 14 | } 15 | 16 | int main(int argc, char *argv[]) { 17 | mainQ(atoi(argv[1]), atoi(argv[2])); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/24.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int j, int k, int n) { 6 | int i = 0; 7 | 8 | for (i = 0; i < n; i++) { 9 | 10 | for (j = i; j < n; j++) { 11 | 12 | for (k = j; k < n; k++) { 13 | //%%%traces: int k, int j, int n, int i 14 | //assert(k >= i); 15 | } 16 | } 17 | } 18 | //%%%traces: int k, int j, int n, int i 19 | } 20 | 21 | int main(int argc, char *argv[]) { 22 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/27.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int l, int i, int k, int n) { 6 | assert(l > 0); 7 | 8 | for (k = 1; k < n; k++) { 9 | 10 | for (i = l; i < n; i++) { 11 | } 12 | 13 | for (i = l; i < n; i++) { 14 | //%%%traces: int k, int l, int i, int n 15 | //assert(1 <= k); 16 | } 17 | } 18 | //%%%traces: int k, int l, int i, int n 19 | } 20 | 21 | int main(int argc, char *argv[]) { 22 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3]), atoi(argv[4])); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/28.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int u) { 6 | assert(u > 0); 7 | int x = 0; 8 | int y = 0; 9 | int n = 0; 10 | int i0 = 0; 11 | 12 | while (i0 < u) { 13 | x++; 14 | y++; 15 | i0++; 16 | } 17 | 18 | while (x != n) { 19 | x--; 20 | y--; 21 | } 22 | //%%%traces: int y, int n, int x 23 | //assert(y == n); 24 | } 25 | 26 | int main(int argc, char *argv[]) { 27 | mainQ(atoi(argv[1])); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/30.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(void) { 6 | int i = 0; 7 | int c = 0; 8 | 9 | while (i < 1000) { 10 | c = c + i; 11 | i = i + 1; 12 | } 13 | 14 | //%%%traces: int c, int i 15 | //assert(c >= 0); 16 | } 17 | 18 | int main(int argc, char *argv[]) { 19 | mainQ(); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/32.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int j) { 6 | int i = j; 7 | int k = 100; 8 | int b = 0; 9 | int n = 0; 10 | for (n = 0; n < 2 * k; n++) { 11 | if (b != 0) { 12 | i++; 13 | b = 0; 14 | } else { 15 | j++; 16 | b = 1; 17 | } 18 | } 19 | //%%%traces: int i, int j, int k, int b, int n 20 | //assert(i == j); 21 | } 22 | 23 | int main(int argc, char *argv[]) { 24 | mainQ(atoi(argv[1])); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/34.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | int x = 0; 7 | int y = 0; 8 | int i = 0; 9 | int m = 10; 10 | 11 | while (i < n) { 12 | i++; 13 | x++; 14 | if (i % 2 == 0) y++; 15 | } 16 | //%%%traces: int x, int y, int i, int m 17 | //if (i == m) assert(x == 2 * y); 18 | } 19 | 20 | int main(int argc, char *argv[]) { 21 | mainQ(atoi(argv[1])); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/35.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | int x = 0; 7 | while (x < n) { 8 | x++; 9 | } 10 | 11 | //%%%traces: int x, int n 12 | //if (n > 0) assert(x == n); 13 | } 14 | 15 | int main(int argc, char *argv[]) { 16 | mainQ(atoi(argv[1])); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/37.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n, int u1) { 6 | assert(u1 > 0); 7 | int x = 0; 8 | int m = 0; 9 | 10 | while (x < n) { 11 | if (u1) { 12 | m = x; 13 | } 14 | x = x + 1; 15 | } 16 | 17 | //%%%traces: int n, int m, int x 18 | //if (n > 0) assert(0 <= m && m < n); 19 | } 20 | 21 | int main(int argc, char *argv[]) { 22 | mainQ(atoi(argv[1]), atoi(argv[2])); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/38.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | int x = 0; 7 | int y = 0; 8 | int i = 0; 9 | 10 | while (i < n) { 11 | i++; 12 | x++; 13 | if (i % 2 == 0) y++; 14 | } 15 | //%%%traces: int i, int x, int y 16 | //if (i % 2 == 0) assert(x == 2 * y); 17 | } 18 | 19 | int main(int argc, char *argv[]) { 20 | mainQ(atoi(argv[1])); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/41.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n, int kt, int flag) { 6 | assert(n >= 0); 7 | int k = 1; 8 | if (flag != 0) { 9 | assert(kt >= 0); 10 | k = kt; 11 | } 12 | int i = 0; 13 | int j = 0; 14 | 15 | while (i <= n) { 16 | i++; 17 | j += i; 18 | } 19 | 20 | int z = k + i + j; 21 | //%%%traces: int z, int n, int i, int j 22 | //assert(z > 2 * n); 23 | } 24 | 25 | int main(int argc, char *argv[]) { 26 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/43.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int x, int y, int u1) { 6 | assert(u1 > 0); 7 | assert(x != y); 8 | 9 | int i = 0; 10 | int t = y; 11 | 12 | while (i < u1) { 13 | i++; 14 | if (x > 0) y = y + x; 15 | } 16 | //%%%traces: int y, int t, int i 17 | //assert(y >= t); 18 | } 19 | 20 | int main(int argc, char *argv[]) { 21 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/44.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int k, int flag) { 6 | int j = 0; 7 | int n = 0; 8 | 9 | if (flag == 1) { 10 | n = 1; 11 | } else { 12 | n = 2; 13 | } 14 | 15 | int i = 0; 16 | 17 | while (i <= k) { 18 | i++; 19 | j = j + n; 20 | } 21 | 22 | //%%%traces: int j, int i, int k 23 | //if (flag == 1) assert(j == i); 24 | } 25 | 26 | int main(int argc, char *argv[]) { 27 | mainQ(atoi(argv[1]), atoi(argv[2])); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/46.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int u1) { 6 | assert(u1 > 0); 7 | int w = 1; 8 | int z = 0; 9 | int x = 0; 10 | int y = 0; 11 | int i1 = 0; 12 | while (i1 < u1) { 13 | i1++; 14 | if (w % 2 == 1) { 15 | x++; 16 | w++; 17 | }; 18 | if (z % 2 == 0) { 19 | y++; 20 | z++; 21 | }; 22 | } 23 | //%%%traces: int x, int z, int y, int w 24 | //assert(x <= 1); 25 | } 26 | 27 | int main(int argc, char *argv[]) { 28 | mainQ(atoi(argv[1])); 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H01.java: -------------------------------------------------------------------------------- 1 | public class H01 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int n){ 8 | assert(n>0); 9 | int x = 1; 10 | int y = 1; 11 | int j = 0; 12 | 13 | while (j < n) { 14 | int t1 = x; 15 | int t2 = y; 16 | x = t1 + t2; 17 | y = t1 + t2; 18 | j = j + 1; 19 | } 20 | //%%%traces: int x, int y 21 | 22 | //assert(y >= 1); 23 | 24 | } 25 | 26 | 27 | } 28 | 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H02.java: -------------------------------------------------------------------------------- 1 | public class H02 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int n){ 8 | assert(n>0); 9 | int i = 1; 10 | int j = 0; 11 | int z = i - j; 12 | int x = 0; 13 | int y = 0; 14 | int w = 0; 15 | int u = 0; 16 | 17 | while (u < n) { 18 | z += x + y + w; 19 | y++; 20 | if (z % 2 == 1) x++; 21 | w += 2; 22 | u = u + 1; 23 | } 24 | 25 | //%%%traces: int x, int y 26 | //assert(x == y); 27 | } 28 | } 29 | 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H03.java: -------------------------------------------------------------------------------- 1 | public class H03 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1]), Integer.parseInt(args[2])); 5 | } 6 | 7 | public static void mainQ(int i, int n, int l) { 8 | assert(l > 0); 9 | int t = 0; 10 | int k = 0; 11 | 12 | for (k = 1; k < n; k++) { 13 | 14 | for (i = l; i < n; i++) { 15 | t = t + 1; 16 | } 17 | 18 | for (i = l; i < n; i++) { 19 | t = t + 1; 20 | } 21 | } 22 | //%%%traces: int i, int k, int n, int l, int t 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H04.java: -------------------------------------------------------------------------------- 1 | public class H04 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int y){ 8 | int x = -50; 9 | 10 | while (x < 0) { 11 | x = x + y; 12 | y++; 13 | } 14 | 15 | //%%%traces: int x, int y 16 | //assert(y > 0); 17 | } 18 | } 19 | 20 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H05.java: -------------------------------------------------------------------------------- 1 | public class H05 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static void mainQ(int flag, int n){ 8 | assert(n > 0); 9 | int j = 0; 10 | int i = 0; 11 | int x = 0; 12 | int y = 0; 13 | int u = 0; 14 | 15 | while (u < n) { 16 | u++; 17 | x++; 18 | y++; 19 | i += x; 20 | j += y; 21 | if (flag != 0) j += 1; 22 | } 23 | //%%%traces: int i, int j 24 | 25 | //assert(j >= i); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H07.java: -------------------------------------------------------------------------------- 1 | public class H07 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static void mainQ(int n, int u1) { 8 | assert(n >= 0&& u1 > 0); 9 | 10 | int a = 0; 11 | int b = 0; 12 | int i = 0; 13 | int u = 0; 14 | 15 | while (i < n) { 16 | if (u < u1) { 17 | a = a + 1; 18 | b = b + 2; 19 | } else { 20 | a = a + 2; 21 | b = b + 1; 22 | } 23 | i = i + 1; 24 | u++; 25 | } 26 | //%%%traces: int a, int b, int n 27 | 28 | //assert(a + b == 3 * n); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H10.java: -------------------------------------------------------------------------------- 1 | public class H10 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int u1){ 8 | assert(u1 > 0); 9 | int i1 = 0; 10 | int w = 1; 11 | int z = 0; 12 | int x = 0; 13 | int y = 0; 14 | 15 | while (i1 < u1) { 16 | i1++; 17 | if (w == 1) { 18 | x++; 19 | w = 0; 20 | }; 21 | if (z == 0) { 22 | y++; 23 | z = 1; 24 | }; 25 | } 26 | 27 | //%%%traces: int x, int y, int u1 28 | //assert(x == y); 29 | } 30 | } 31 | 32 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H11.java: -------------------------------------------------------------------------------- 1 | public class H11 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int n){ 8 | int j = 0; 9 | int x = 100; 10 | int i = 0; 11 | 12 | for (i = 0; i < x; i++) { 13 | j = j + 2; 14 | } 15 | //%%%traces: int j, int x, int i, int n 16 | //assert(j == 2 * x); 17 | } 18 | 19 | 20 | } 21 | 22 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H13.java: -------------------------------------------------------------------------------- 1 | public class H13 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static void mainQ(int flag, int u1) { 8 | assert(u1 > 0); 9 | int j = 2; 10 | int k = 0; 11 | int i0 = 0; 12 | 13 | while (i0 < u1) { 14 | i0++; 15 | if (flag != 0) 16 | j = j + 4; 17 | else { 18 | j = j + 2; 19 | k = k + 1; 20 | } 21 | } 22 | 23 | //%%%traces: int j, int k 24 | //if (k != 0) assert(j == 2 * k + 2); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H14.java: -------------------------------------------------------------------------------- 1 | public class H14 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static void mainQ(int m, int u4) { 8 | assert(m > 0); 9 | 10 | int a = 0; 11 | int j = 0; 12 | for (j = 1; j <= m; j++) { 13 | if (u4!=0) 14 | a++; 15 | else 16 | a--; 17 | } 18 | 19 | //%%%traces: int a, int m 20 | //assert(a >= 0 - m); 21 | //assert(a <= m); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H15.java: -------------------------------------------------------------------------------- 1 | public class H15 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static void mainQ(int n, int k) { 8 | assert(n > 0); 9 | assert(k > n); 10 | 11 | int j = 0; 12 | while (j < n) { 13 | j++; 14 | k--; 15 | } 16 | //%%%traces: int k, int n 17 | //assert(k >= 0); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H16.java: -------------------------------------------------------------------------------- 1 | public class H16 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static void mainQ(int i, int j) { 8 | int x = i; 9 | int y = j; 10 | 11 | while (x != 0) { 12 | x--; 13 | y--; 14 | } 15 | //%%%traces: int i, int j, int y 16 | //if (i == j) assert(y == 0); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H17.java: -------------------------------------------------------------------------------- 1 | public class H17 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int n){ 8 | assert(n > 0); 9 | int k = 1; 10 | int i = 1; 11 | int j = 0; 12 | 13 | while (i < n) { 14 | j = 0; 15 | while (j < i) { 16 | k += (i - j); 17 | j++; 18 | } 19 | i++; 20 | } 21 | //%%%traces: int k, int n 22 | //assert(k >= n); 23 | 24 | } 25 | } 26 | 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H18.java: -------------------------------------------------------------------------------- 1 | public class H18 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1]), Integer.parseInt(args[2])); 5 | } 6 | 7 | public static void mainQ(int a, int b, int flag) { 8 | int j = 0; 9 | for (b = 0; b < 100; ++b) { 10 | if (flag != 0) j = j + 1; 11 | } 12 | 13 | //%%%traces: int j, int flag, int a, int b 14 | //if (flag != 0) assert(j == 100); 15 | 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H19.java: -------------------------------------------------------------------------------- 1 | public class H19 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static void mainQ(int m, int n) { 8 | assert(n >= 0); 9 | assert(m >= 0); 10 | assert(m < n); 11 | 12 | int x = 0; 13 | int y = m; 14 | 15 | while (x < n) { 16 | x++; 17 | if (x > m) y++; 18 | } 19 | 20 | //%%%traces: int y, int n 21 | //assert(y == n); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H22.java: -------------------------------------------------------------------------------- 1 | public class H22 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int u1){ 8 | assert(u1 > 0); 9 | int x = 0; 10 | int y = 0; 11 | int z = 0; 12 | int k = 0; 13 | int i0 = 0; 14 | 15 | while (i0 < u1) { 16 | i0++; 17 | if (k % 3 == 0) x++; 18 | y++; 19 | z++; 20 | k = x + y + z; 21 | } 22 | 23 | //%%%traces: int x, int y, int z 24 | //assert(x == y); 25 | //assert(y == z); 26 | 27 | } 28 | } 29 | 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H23.java: -------------------------------------------------------------------------------- 1 | public class H23 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static void mainQ(int i, int n) { 8 | assert(n >= 0); 9 | int s = 0; 10 | for (i = 0; i < n; ++i) { 11 | s = s + i; 12 | } 13 | 14 | //%%%traces: int s, int i, int n 15 | //assert(s >= 0); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H24.java: -------------------------------------------------------------------------------- 1 | public class H24 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1]), Integer.parseInt(args[2])); 5 | } 6 | 7 | public static void mainQ(int j, int k, int n) { 8 | int i = 0; 9 | 10 | for (i = 0; i < n; i++) { 11 | 12 | for (j = i; j < n; j++) { 13 | 14 | for (k = j; k < n; k++) { 15 | //%%%traces: int k, int j, int n, int i 16 | //assert(k >= i); 17 | } 18 | } 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H27.java: -------------------------------------------------------------------------------- 1 | public class H27 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1]), Integer.parseInt(args[2]),Integer.parseInt(args[3])); 5 | } 6 | 7 | public static void mainQ(int l, int i, int k, int n) { 8 | assert(l > 0); 9 | 10 | for (k = 1; k < n; k++) { 11 | 12 | for (i = l; i < n; i++) { 13 | } 14 | 15 | for (i = l; i < n; i++) { 16 | //%%%traces: int k, int l, int i, int n 17 | //assert(1 <= k); 18 | } 19 | } 20 | //%%%traces: int k, int l, int i, int n 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H28.java: -------------------------------------------------------------------------------- 1 | public class H28 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int u){ 8 | assert(u > 0); 9 | int x = 0; 10 | int y = 0; 11 | int n = 0; 12 | int i0 = 0; 13 | 14 | while (i0 < u) { 15 | x++; 16 | y++; 17 | i0++; 18 | } 19 | 20 | while (x != n) { 21 | x--; 22 | y--; 23 | } 24 | //%%%traces: int y, int n, int x, int u, int i0 25 | //assert(y == n); 26 | } 27 | } 28 | 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H30.java: -------------------------------------------------------------------------------- 1 | public class H30 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int n){ 8 | int i = 0; 9 | int c = 0; 10 | 11 | while (i < 1000) { 12 | c = c + i; 13 | i = i + 1; 14 | } 15 | 16 | //%%%traces: int c, int i, int n 17 | //assert(c >= 0); 18 | } 19 | 20 | 21 | } 22 | 23 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H32.java: -------------------------------------------------------------------------------- 1 | public class H32 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int j){ 8 | int i = j; 9 | int k = 100; 10 | int b = 0; 11 | int n = 0; 12 | for (n = 0; n < 2 * k; n++) { 13 | if (b != 0) { 14 | i++; 15 | b = 0; 16 | } else { 17 | j++; 18 | b = 1; 19 | } 20 | } 21 | //%%%traces: int i, int j, int k, int b, int n 22 | //assert(i == j); 23 | } 24 | } 25 | 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H34.java: -------------------------------------------------------------------------------- 1 | public class H34 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int n){ 8 | int x = 0; 9 | int y = 0; 10 | int i = 0; 11 | int m = 10; 12 | 13 | while (i < n) { 14 | i++; 15 | x++; 16 | if (i % 2 == 0) y++; 17 | } 18 | //%%%traces: int x, int y, int i, int m, int n 19 | //if (i == m) assert(x == 2 * y); 20 | } 21 | } 22 | 23 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H35.java: -------------------------------------------------------------------------------- 1 | public class H35 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int n){ 8 | int x = 0; 9 | while (x < n) { 10 | x++; 11 | } 12 | 13 | //%%%traces: int x, int n 14 | //if (n > 0) assert(x == n); 15 | } 16 | } 17 | 18 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H37.java: -------------------------------------------------------------------------------- 1 | public class H37 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static void mainQ(int n, int u1) { 8 | assert(u1 > 0); 9 | int x = 0; 10 | int m = 0; 11 | 12 | while (x < n) { 13 | if (u1 != 0) { 14 | m = x; 15 | } 16 | x = x + 1; 17 | } 18 | 19 | //%%%traces: int n, int m, int x 20 | //if (n > 0) assert(0 <= m && m < n); 21 | } 22 | 23 | 24 | } 25 | 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H38.java: -------------------------------------------------------------------------------- 1 | public class H38 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int n){ 8 | int x = 0; 9 | int y = 0; 10 | int i = 0; 11 | 12 | while (i < n) { 13 | i++; 14 | x++; 15 | if (i % 2 == 0) y++; 16 | } 17 | //%%%traces: int i, int x, int y, int n 18 | //if (i % 2 == 0) assert(x == 2 * y); 19 | } 20 | } 21 | 22 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H41.java: -------------------------------------------------------------------------------- 1 | public class H41 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1]), Integer.parseInt(args[2])); 5 | } 6 | 7 | public static void mainQ(int n, int kt, int flag) { 8 | assert(n >= 0); 9 | int k = 1; 10 | if (flag != 0) { 11 | assert(kt >= 0); 12 | k = kt; 13 | } 14 | int i = 0; 15 | int j = 0; 16 | 17 | while (i <= n) { 18 | i++; 19 | j += i; 20 | } 21 | 22 | int z = k + i + j; 23 | //%%%traces: int z, int n, int i, int j 24 | //assert(z > 2 * n); 25 | 26 | 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H43.java: -------------------------------------------------------------------------------- 1 | public class H43 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1]), Integer.parseInt(args[2])); 5 | } 6 | 7 | public static void mainQ(int x, int y, int u1) { 8 | assert(u1 > 0); 9 | assert(x != y); 10 | 11 | int i = 0; 12 | int t = y; 13 | 14 | while (i < u1) { 15 | i++; 16 | if (x > 0) y = y + x; 17 | } 18 | //%%%traces: int y, int t, int i 19 | //assert(y >= t); 20 | 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H44.java: -------------------------------------------------------------------------------- 1 | public class H44 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0]), Integer.parseInt(args[1])); 5 | } 6 | 7 | public static void mainQ(int k, int flag) { 8 | int j = 0; 9 | int n = 0; 10 | 11 | if (flag == 1) { 12 | n = 1; 13 | } else { 14 | n = 2; 15 | } 16 | 17 | int i = 0; 18 | 19 | while (i <= k) { 20 | i++; 21 | j = j + n; 22 | } 23 | 24 | //%%%traces: int j, int i, int k, int flag 25 | //if (flag == 1) assert(j == i); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/H46.java: -------------------------------------------------------------------------------- 1 | public class H46 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static void mainQ(int u1){ 8 | assert(u1 > 0); 9 | int w = 1; 10 | int z = 0; 11 | int x = 0; 12 | int y = 0; 13 | int i1 = 0; 14 | while (i1 < u1) { 15 | i1++; 16 | if (w % 2 == 1) { 17 | x++; 18 | w++; 19 | }; 20 | if (z % 2 == 0) { 21 | y++; 22 | z++; 23 | }; 24 | } 25 | //%%%traces: int x, int z, int y, int w, int u1 26 | //assert(x <= 1); 27 | 28 | } 29 | } 30 | 31 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/01.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * IC3 motivating example 9 | */ 10 | 11 | void main() 12 | { 13 | int x=1; int y=1; 14 | while(unknown1()) { 15 | int t1 = x; 16 | int t2 = y; 17 | x = t1+ t2; 18 | y = t1 + t2; 19 | } 20 | static_assert(y>=1); 21 | } 22 | 23 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/02.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | int main() 8 | { 9 | int i = 1; 10 | int j = 0; 11 | int z = i-j; 12 | int x = 0; 13 | int y = 0; 14 | int w = 0; 15 | 16 | while(unknown2()) 17 | { 18 | z+=x+y+w; 19 | y++; 20 | if(z%2==1) 21 | x++; 22 | w+=2; 23 | } 24 | 25 | static_assert(x==y); 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/03.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /* 4 | * "nested4.c" from InvGen benchmark suite 5 | */ 6 | 7 | 8 | void main() { 9 | int i,k,n,l; 10 | 11 | 12 | assume(l>0); 13 | 14 | for (k=1;k 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * Taken from Gulwani PLDI'08: 9 | * Program Analysis as Constraint Solving 10 | */ 11 | 12 | void main() { 13 | int x,y; 14 | 15 | x = -50; 16 | while( x < 0 ) { 17 | x = x+y; 18 | y++; 19 | } 20 | static_assert(y>0); 21 | } 22 | 23 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/05.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | void main(int flag) 8 | { 9 | 10 | int x = 0; 11 | int y = 0; 12 | 13 | int j = 0; 14 | int i = 0; 15 | 16 | 17 | while(unknown1()) 18 | { 19 | x++; 20 | y++; 21 | i+=x; 22 | j+=y; 23 | if(flag) j+=1; 24 | } 25 | static_assert(j>=i); 26 | 27 | } 28 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/06.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | void main() 8 | { 9 | 10 | 11 | int w = 1; 12 | int z = 0; 13 | int x= 0; 14 | int y=0; 15 | 16 | while(unknown1()){ 17 | 18 | while(unknown2()){ 19 | if(w%2 == 1) x++; 20 | if(z%2==0) y++; 21 | } 22 | z=x+y; 23 | w=z+1; 24 | } 25 | 26 | 27 | static_assert(x==y); 28 | } 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/07.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * From "Path Invariants" PLDI 07 by Beyer et al. 9 | */ 10 | 11 | int main(int argc, char* argv[]) { 12 | 13 | int i, n, a, b; 14 | assume( n >= 0 ); 15 | i = 0; a = 0; b = 0; 16 | while( i < n ) { 17 | if(unknown1()) { 18 | a = a+1; 19 | b = b+2; 20 | } else { 21 | a = a+2; 22 | b = b+1; 23 | } 24 | i = i+1; 25 | } 26 | static_assert( a+b == 3*n ); 27 | } 28 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/08.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | 6 | /* 7 | * Based on "Automatically refining abstract interpretations" fig.1 8 | */ 9 | 10 | 11 | void main() { 12 | int x = 0, y = 0; 13 | while(unknown1()){ 14 | if(unknown2()){ 15 | x++; 16 | y+=100; 17 | } 18 | else if (unknown3()){ 19 | if (x >= 4) { 20 | x++; 21 | y++; 22 | } 23 | if (x < 0){ 24 | y--; 25 | } 26 | } 27 | 28 | } 29 | static_assert(x < 4 || y > 2); 30 | } 31 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/10.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | void main() { 8 | 9 | 10 | int w = 1; 11 | int z = 0; 12 | int x= 0; 13 | int y=0; 14 | 15 | 16 | while(unknown2()){ 17 | if(w) { 18 | x++; 19 | w=!w; 20 | }; 21 | if(!z) { 22 | y++; 23 | z=!z; 24 | }; 25 | } 26 | 27 | 28 | static_assert(x==y); 29 | 30 | } 31 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/11.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * Based on ex3 from NECLA Static Analysis Benchmarks 9 | */ 10 | 11 | 12 | void main() 13 | { 14 | int j=0; 15 | int i; 16 | int x=100; 17 | 18 | 19 | for (i =0; i< x ; i++){ 20 | j = j + 2; 21 | } 22 | 23 | static_assert(j == 2*x); 24 | } 25 | 26 | 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/12.c: -------------------------------------------------------------------------------- 1 | int unknown1(); 2 | int unknown2(); 3 | 4 | 5 | int main(int flag) 6 | { 7 | int t = 0; 8 | int s = 0; 9 | int a = 0; 10 | int b = 0; 11 | while(unknown1()){ 12 | a++; 13 | b++; 14 | s+=a; 15 | t+=b; 16 | if(flag){ 17 | t+=a; 18 | } 19 | } 20 | //2s >= t 21 | int x = 1; 22 | if(flag){ 23 | x = t-2*s+2; 24 | } 25 | //x <= 2 26 | int y = 0; 27 | while(y<=x){ 28 | if(unknown2()) 29 | y++; 30 | else 31 | y+=2; 32 | } 33 | static_assert(y<=4); 34 | } 35 | 36 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/13.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * Based on "Property-Directed Incremental Invariant Generation" by Bradley et al. 9 | */ 10 | 11 | int main(int flag) { 12 | int j = 2; 13 | int k = 0; 14 | 15 | while(unknown1()){ 16 | if (flag) 17 | j = j + 4; 18 | else { 19 | j = j + 2; 20 | k = k + 1; 21 | } 22 | } 23 | if(k!=0) 24 | static_assert(j==2*k+2); 25 | } 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/14.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * From "The Octagon Abstract Domain" HOSC 2006 by Mine. 9 | */ 10 | 11 | int main() { 12 | int a = 0; 13 | int j; 14 | int m; 15 | int __BLAST_NONDET; 16 | if(m<=0) 17 | return 0; 18 | for(j = 1; j <= m ; j++){ 19 | if(unknown1()) 20 | a++; 21 | else 22 | a--; 23 | } 24 | static_assert(a>=-m); 25 | static_assert(a<=m); 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/15.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * from Invgen test suite 9 | */ 10 | 11 | int main(int argc, char* argv[]) { 12 | 13 | int n; 14 | int i, k, j; 15 | 16 | 17 | n = unknown1(); 18 | assume(n>0); 19 | 20 | assume(k>n); 21 | j = 0; 22 | while( j < n ) { 23 | j++; 24 | k--; 25 | } 26 | static_assert(k>=0); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/16.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | 8 | /* 9 | * From "A Practical and Complete Approach to Predicate Refinement" by McMillan TACAS'06 10 | */ 11 | 12 | int main(int i, int j) { 13 | 14 | int x = i; 15 | int y = j; 16 | 17 | while(x!=0) { 18 | x--; 19 | y--; 20 | } 21 | if(i==j) 22 | static_assert(y==0); 23 | } 24 | 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/17.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | void main(int n) 8 | { 9 | int k=1; 10 | int i=1; 11 | int j=0; 12 | while(i=n); 21 | 22 | } 23 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/18.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * Adapted from ex17.c in NECLA test suite 9 | */ 10 | 11 | int main(int flag, int a) { 12 | int b; 13 | int j = 0; 14 | 15 | for (b=0; b < 100 ; ++b){ 16 | if (flag) 17 | j = j +1; 18 | } 19 | 20 | 21 | if(flag) 22 | static_assert(j==100); 23 | } 24 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/19.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * From "Simplifying Loop Invariant Generation using Splitter Predicates", Sharma et al. CAV'11 9 | */ 10 | 11 | 12 | void main(int n, int m) 13 | { 14 | assume(n>=0); 15 | assume(m>=0); 16 | assume(mm) y++; 22 | } 23 | static_assert(y==n); 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/22.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | void main() 8 | { 9 | int x = 0; 10 | int y = 0; 11 | int z = 0; 12 | int k = 0; 13 | 14 | while(unknown1()) 15 | { 16 | if(k%3 == 0) 17 | x++; 18 | y++; 19 | z++; 20 | k = x+y+z; 21 | } 22 | 23 | static_assert(x==y); 24 | static_assert(y==z); 25 | 26 | } 27 | 28 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/23.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * ex49 from NECLA Static Analysis Benchmarks 9 | */ 10 | 11 | 12 | int main( int n){ 13 | int i, sum=0; 14 | assume( n >= 0); 15 | 16 | for (i=0; i < n; ++i) 17 | sum = sum +i; 18 | 19 | static_assert(sum >= 0); 20 | } 21 | 22 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/24.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * "nested5.c" from InvGen test suite 9 | */ 10 | 11 | void main() { 12 | int i,j,k,n; 13 | 14 | for (i=0;i=i); 18 | } 19 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/25.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | void main() 8 | { 9 | int x = 0; 10 | int y = 0; 11 | int i = 0; 12 | int j = 0; 13 | 14 | while(unknown1()) 15 | { 16 | while(unknown2()) 17 | { 18 | if(x==y) 19 | i++; 20 | else 21 | j++; 22 | } 23 | if(i>=j) 24 | { 25 | x++; 26 | y++; 27 | } 28 | else 29 | y++; 30 | } 31 | 32 | static_assert(i>=j); 33 | } 34 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/26.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | void main() 8 | { 9 | int w=1, z=0, x=0, y=0; 10 | while(unknown1()){ 11 | while(unknown2()){ 12 | if(w%2 == 1) 13 | x++; 14 | if(z%2==0) 15 | y++; 16 | } 17 | while(unknown4()) 18 | { 19 | z=x+y; 20 | w=z+1; 21 | } 22 | } 23 | static_assert(x==y); 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/27.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /* 4 | * "nested2.c" from InvGen benchmark suite 5 | */ 6 | 7 | 8 | void main() { 9 | int i,k,n,l; 10 | 11 | 12 | assume(l>0); 13 | 14 | for (k=1;k 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | 8 | /* 9 | * From CAV'12 by Sharma et al. 10 | */ 11 | 12 | void main() { 13 | int x=0; 14 | int y=0; 15 | int n = 0; 16 | while(unknown()) { 17 | x++; 18 | y++; 19 | } 20 | while(x!=n) { 21 | x--; 22 | y--; 23 | } 24 | static_assert(y==n); 25 | } 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/29.c: -------------------------------------------------------------------------------- 1 | int unknown1(); 2 | int unknown2(); 3 | int unknown3(); 4 | 5 | int main() 6 | { 7 | int a = 1; 8 | int b = 1; 9 | int c = 2; 10 | int d = 2; 11 | int x = 3; 12 | int y = 3; 13 | while(unknown1()) 14 | { 15 | x = a+c; 16 | y = b+d; 17 | if((x+y)%2 == 0) 18 | { 19 | a++; 20 | d++; 21 | }else 22 | { 23 | a--; 24 | } 25 | while(unknown2()) 26 | { 27 | c--; 28 | b--; 29 | } 30 | } 31 | static_assert(a+c==b+d); 32 | } 33 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/30.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * Based on "SYNERGY: A New Algorithm for Property Checking" by Gulavani et al. 9 | */ 10 | 11 | int main() { 12 | 13 | int i, c; 14 | i = 0; 15 | c = 0; 16 | while (i < 1000) { 17 | c = c + i; 18 | i = i + 1; 19 | } 20 | 21 | static_assert(c>=0); 22 | } 23 | 24 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/31.c: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | int unknown1(); 4 | 5 | /* 6 | * "nest-if8" from InvGen benchmark suite 7 | */ 8 | 9 | 10 | int main() { 11 | int i,j,k,n,m; 12 | if( m+1 < n ); else return; 13 | for ( i=0; i= 0 ); 17 | j++; 18 | k = 0; 19 | while( k < j ) { 20 | k++; 21 | } 22 | } 23 | else { 24 | static_assert( n+j+5>i ); 25 | j+= 2; 26 | } 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/32.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /* 4 | * "split.c" from InvGen benchmark suite 5 | */ 6 | 7 | 8 | void main() { 9 | int k = 100; 10 | int b; 11 | int i; 12 | int j; 13 | int n; 14 | i = j; 15 | for( n = 0 ; n < 2*k ; n++ ) { 16 | if(b) { 17 | i++; 18 | } else { 19 | j++; 20 | } 21 | b = !b; 22 | } 23 | static_assert(i == j); 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/33.c: -------------------------------------------------------------------------------- 1 | int unknown1(); 2 | int unknown2(); 3 | int unknown3(); 4 | 5 | int main(int k) 6 | { 7 | int z = k; 8 | int x = 0; 9 | int y = 0; 10 | 11 | while(unknown1()) 12 | { 13 | int c = 0; 14 | while(unknown2()) 15 | { 16 | if(z==k+y-c) 17 | { 18 | x++; 19 | y++; 20 | c++; 21 | }else 22 | { 23 | x++; 24 | y--; 25 | c++; 26 | } 27 | } 28 | while(unknown3()) 29 | { 30 | x--; 31 | y--; 32 | } 33 | z=k+y; 34 | } 35 | static_assert(x==y); 36 | } 37 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/34.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | void main(int n) 8 | { 9 | int x=0; 10 | int y=0; 11 | int i=0; 12 | int m=10; 13 | 14 | 15 | while(i 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * InvGen, CAV'09 paper, fig 2 9 | */ 10 | 11 | void main(int n) { 12 | int x= 0; 13 | while(x0) static_assert(x==n); 17 | } 18 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/37.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * Taken from "Counterexample Driven Refinement for Abstract Interpretation" (TACAS'06) by Gulavani 9 | */ 10 | 11 | void main(int n) { 12 | int x= 0; 13 | int m=0; 14 | while(x0) static_assert(0<=m && m 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | void main(int n) 8 | { 9 | int x=0; 10 | int y=0; 11 | int i=0; 12 | 13 | while(i 2 | int unknown1(); 3 | int unknown2(); 4 | 5 | void main( int flag) 6 | { 7 | int i, j, k; 8 | j = 1; 9 | if(flag) {i=0;} 10 | else {i=1;} 11 | 12 | 13 | while(unknown1()) { 14 | i+=2; 15 | if(i%2 == 0) { 16 | j+=2; 17 | } 18 | else j++; 19 | } 20 | 21 | int a = 0; 22 | int b=0; 23 | 24 | while(unknown2()) { 25 | a++; 26 | b+=(j-i); 27 | } 28 | if(flag) 29 | static_assert(a==b); 30 | } 31 | 32 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/41.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * Adapted from "Automated Error Diagnosis Using Abductive Inference" by Dillig et al. 9 | */ 10 | 11 | int main(int n, int flag) { 12 | assume(n>=0); 13 | int k = 1; 14 | if(flag) { 15 | k = unknown1(); 16 | assume(k>=0); 17 | } 18 | int i = 0, j = 0; 19 | while(i <= n) { 20 | i++; 21 | j+=i; 22 | } 23 | int z = k + i + j; 24 | static_assert(z > 2*n); 25 | } 26 | 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/42.c: -------------------------------------------------------------------------------- 1 | 2 | int unknown1(); 3 | int unknown2(); 4 | 5 | void main(int flag) 6 | { 7 | int x = 1; 8 | int y = 1; 9 | int a; 10 | 11 | if(flag) 12 | a = 0; 13 | else 14 | a = 1; 15 | 16 | while(unknown1()){ 17 | if(flag) 18 | { 19 | a = x+y; 20 | x++; 21 | } 22 | else 23 | { 24 | a = x+y+1; 25 | y++; 26 | } 27 | if(a%2==1) 28 | y++; 29 | else 30 | x++; 31 | } 32 | //x==y 33 | 34 | if(flag) 35 | a++; 36 | static_assert(a%2==1); 37 | } 38 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/43.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * Based on ex16 from NECLA Static Analysis Benchmarks 9 | */ 10 | 11 | 12 | int main(int x, int y) 13 | { 14 | int i=0; 15 | int t=y; 16 | 17 | if (x==y) return x; 18 | 19 | while (unknown1()){ 20 | if (x > 0) 21 | y = y + x; 22 | } 23 | 24 | 25 | static_assert(y>=t); 26 | 27 | } 28 | 29 | 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/44.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | /* 8 | * Adapted from ex20 from NECLA Static Analysis Benchmarks 9 | */ 10 | 11 | 12 | int main(int k, int flag) 13 | { 14 | int i=0; 15 | int j=0; 16 | int n; 17 | int __BLAST_NONDET; 18 | 19 | 20 | if (flag == 1){ 21 | n=1; 22 | } else { 23 | n=2; 24 | } 25 | 26 | i=0; 27 | 28 | while ( i <= k){ 29 | i++; 30 | j= j +n; 31 | } 32 | if(flag == 1) 33 | static_assert(j == i); 34 | 35 | } 36 | 37 | 38 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/bm_hola/orig_bms/46.c: -------------------------------------------------------------------------------- 1 | #include 2 | int unknown1(); 3 | int unknown2(); 4 | int unknown3(); 5 | int unknown4(); 6 | 7 | void main() 8 | { 9 | 10 | 11 | int w = 1; 12 | int z = 0; 13 | int x= 0; 14 | int y=0; 15 | 16 | 17 | while(unknown2()){ 18 | if(w%2 == 1) {x++; w++;}; 19 | if(z%2==0) {y++; z++;}; 20 | } 21 | 22 | 23 | static_assert(x<=1); 24 | } 25 | 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/01.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | assert(n>0); 7 | int x = 1; 8 | int y = 1; 9 | int j = 0; 10 | 11 | while (j < n) { 12 | int t1 = x; 13 | int t2 = y; 14 | x = t1 + t2; 15 | y = t1 + t2; 16 | j = j + 1; 17 | } 18 | //%%%traces: int x, int y 19 | 20 | //assert(y >= 1); 21 | } 22 | 23 | int main(int argc, char *argv[]) { 24 | mainQ(atoi(argv[1])); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/02.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | assert (n > 0); 7 | int i = 1; 8 | int j = 0; 9 | int z = i - j; 10 | int x = 0; 11 | int y = 0; 12 | int w = 0; 13 | int u = 0; 14 | 15 | while (u < n) { 16 | z += x + y + w; 17 | y++; 18 | if (z % 2 == 1) x++; 19 | w += 2; 20 | u = u + 1; 21 | } 22 | 23 | //%%%traces: int x, int y 24 | //assert(x == y); 25 | } 26 | 27 | int main(int argc, char *argv[]) { 28 | mainQ(atoi(argv[1])); 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/03.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int i, int n, int l) { 6 | assert(l > 0); 7 | int t = 0; 8 | int k = 0; 9 | 10 | for (k = 1; k < n; k++) { 11 | 12 | for (i = l; i < n; i++) { 13 | t = t + 1; 14 | } 15 | 16 | for (i = l; i < n; i++) { 17 | t = t + 1; 18 | } 19 | } 20 | //%%%traces: int i, int k, int n, int l, int t 21 | } 22 | 23 | int main(int argc, char *argv[]) { 24 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/04.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int y) { 6 | int x = -50; 7 | 8 | while (x < 0) { 9 | x = x + y; 10 | y++; 11 | } 12 | 13 | //%%%traces: int x, int y 14 | //assert(y > 0); 15 | } 16 | 17 | int main(int argc, char *argv[]) { 18 | mainQ(atoi(argv[1])); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/05.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int flag, int n) { 6 | assert(n > 0); 7 | int j = 0; 8 | int i = 0; 9 | int x = 0; 10 | int y = 0; 11 | int u = 0; 12 | 13 | while (u < n) { 14 | u++; 15 | x++; 16 | y++; 17 | i += x; 18 | j += y; 19 | if (flag != 0) j += 1; 20 | } 21 | //%%%traces: int i, int j 22 | 23 | //assert(j >= i); 24 | } 25 | 26 | int main(int argc, char *argv[]) { 27 | mainQ(atoi(argv[1]), atoi(argv[2])); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/06.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n1, int n2) { 6 | int w = 1; 7 | int z = 0; 8 | int x = 0; 9 | int y = 0; 10 | int i1 = 0; 11 | int i2 = 0; 12 | 13 | while (i1 < n1) { 14 | 15 | i2 = 0; 16 | while (i2 < n2) { 17 | 18 | if (w % 2 == 1) x++; 19 | if (z % 2 == 0) y++; 20 | i2++; 21 | } 22 | 23 | z = x + y; 24 | w = z + 1; 25 | i1++; 26 | } 27 | //%%%traces: int x, int y 28 | 29 | //assert(x == y); 30 | } 31 | 32 | int main(int argc, char *argv[]) { 33 | mainQ(atoi(argv[1]), atoi(argv[2])); 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/07.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n, int u1) { 6 | assert(n >= 0&& u1 > 0); 7 | 8 | int a = 0; 9 | int b = 0; 10 | int i = 0; 11 | int u = 0; 12 | 13 | while (i < n) { 14 | if (u < u1) { 15 | a = a + 1; 16 | b = b + 2; 17 | } else { 18 | a = a + 2; 19 | b = b + 1; 20 | } 21 | i = i + 1; 22 | u++; 23 | } 24 | //%%%traces: int a, int b, int n 25 | 26 | //assert(a + b == 3 * n); 27 | } 28 | 29 | int main(int argc, char *argv[]) { 30 | mainQ(atoi(argv[1]), atoi(argv[2])); 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/10.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int u1) { 6 | assert(u1 > 0); 7 | int i1 = 0; 8 | int w = 1; 9 | int z = 0; 10 | int x = 0; 11 | int y = 0; 12 | 13 | while (i1 < u1) { 14 | i1++; 15 | if (w == 1) { 16 | x++; 17 | w = 0; 18 | }; 19 | if (z == 0) { 20 | y++; 21 | z = 1; 22 | }; 23 | } 24 | 25 | //%%%traces: int x, int y 26 | //assert(x == y); 27 | } 28 | 29 | int main(int argc, char *argv[]) { 30 | mainQ(atoi(argv[1])); 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/11.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(void) { 6 | int j = 0; 7 | int x = 100; 8 | int i = 0; 9 | 10 | for (i = 0; i < x; i++) { 11 | j = j + 2; 12 | } 13 | //%%%traces: int j, int x, int i 14 | //assert(j == 2 * x); 15 | } 16 | 17 | int main(int argc, char *argv[]) { 18 | mainQ(); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/13.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int flag, int u1) { 6 | assert(u1 > 0); 7 | int j = 2; 8 | int k = 0; 9 | int i0 = 0; 10 | 11 | while (i0 < u1) { 12 | i0++; 13 | if (flag != 0) 14 | j = j + 4; 15 | else { 16 | j = j + 2; 17 | k = k + 1; 18 | } 19 | } 20 | 21 | //%%%traces: int j, int k 22 | //if (k != 0) assert(j == 2 * k + 2); 23 | } 24 | 25 | int main(int argc, char *argv[]) { 26 | mainQ(atoi(argv[1]), atoi(argv[2])); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/14.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int m, int u4) { 6 | assert(m > 0); 7 | 8 | int a = 0; 9 | int j = 0; 10 | for (j = 1; j <= m; j++) { 11 | if (u4) 12 | a++; 13 | else 14 | a--; 15 | } 16 | 17 | //%%%traces: int a, int m 18 | //assert(a >= 0 - m); 19 | //assert(a <= m); 20 | } 21 | 22 | int main(int argc, char *argv[]) { 23 | mainQ(atoi(argv[1]), atoi(argv[2])); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/15.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n, int k) { 6 | assert(n > 0); 7 | assert(k > n); 8 | 9 | int j = 0; 10 | while (j < n) { 11 | j++; 12 | k--; 13 | } 14 | //%%%traces: int k, int n 15 | //assert(k >= 0); 16 | } 17 | 18 | int main(int argc, char *argv[]) { 19 | mainQ(atoi(argv[1]), atoi(argv[2])); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/16.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int i, int j) { 6 | int x = i; 7 | int y = j; 8 | 9 | while (x != 0) { 10 | x--; 11 | y--; 12 | } 13 | //%%%traces: int i, int j, int y 14 | //if (i == j) assert(y == 0); 15 | } 16 | 17 | int main(int argc, char *argv[]) { 18 | mainQ(atoi(argv[1]), atoi(argv[2])); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/17.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | assert(n > 0); 7 | int k = 1; 8 | int i = 1; 9 | int j = 0; 10 | 11 | while (i < n) { 12 | j = 0; 13 | while (j < i) { 14 | k += (i - j); 15 | j++; 16 | } 17 | i++; 18 | } 19 | //%%%traces: int k, int n 20 | //assert(k >= n); 21 | } 22 | 23 | int main(int argc, char *argv[]) { 24 | mainQ(atoi(argv[1])); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/18.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int a, int b, int flag) { 6 | int j = 0; 7 | for (b = 0; b < 100; ++b) { 8 | if (flag != 0) j = j + 1; 9 | } 10 | 11 | //%%%traces: int j, int flag, int a, int b 12 | //if (flag != 0) assert(j == 100); 13 | } 14 | 15 | int main(int argc, char *argv[]) { 16 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/19.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int m, int n) { 6 | assert(n >= 0); 7 | assert(m >= 0); 8 | assert(m < n); 9 | 10 | int x = 0; 11 | int y = m; 12 | 13 | while (x < n) { 14 | x++; 15 | if (x > m) y++; 16 | } 17 | 18 | //%%%traces: int y, int n 19 | //assert(y == n); 20 | } 21 | 22 | int main(int argc, char *argv[]) { 23 | mainQ(atoi(argv[1]), atoi(argv[2])); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/22.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int u1) { 6 | assert(u1 > 0); 7 | int x = 0; 8 | int y = 0; 9 | int z = 0; 10 | int k = 0; 11 | int i0 = 0; 12 | 13 | while (i0 < u1) { 14 | i0++; 15 | if (k % 3 == 0) x++; 16 | y++; 17 | z++; 18 | k = x + y + z; 19 | } 20 | 21 | //%%%traces: int x, int y, int z 22 | //assert(x == y); 23 | //assert(y == z); 24 | } 25 | 26 | int main(int argc, char *argv[]) { 27 | mainQ(atoi(argv[1])); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/23.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int i, int n) { 6 | assert(n >= 0); 7 | int sum = 0; 8 | for (i = 0; i < n; ++i) { 9 | sum = sum + i; 10 | } 11 | 12 | //%%%traces: int sum, int i, int n 13 | //assert(sum >= 0); 14 | } 15 | 16 | int main(int argc, char *argv[]) { 17 | mainQ(atoi(argv[1]), atoi(argv[2])); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/24.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int j, int k, int n) { 6 | int i = 0; 7 | 8 | for (i = 0; i < n; i++) { 9 | 10 | for (j = i; j < n; j++) { 11 | 12 | for (k = j; k < n; k++) { 13 | //%%%traces: int k, int j, int n, int i 14 | //assert(k >= i); 15 | } 16 | } 17 | } 18 | //%%%traces: int k, int j, int n, int i 19 | } 20 | 21 | int main(int argc, char *argv[]) { 22 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/27.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int l, int i, int k, int n) { 6 | assert(l > 0); 7 | 8 | for (k = 1; k < n; k++) { 9 | 10 | for (i = l; i < n; i++) { 11 | } 12 | 13 | for (i = l; i < n; i++) { 14 | //%%%traces: int k, int l, int i, int n 15 | //assert(1 <= k); 16 | } 17 | } 18 | //%%%traces: int k, int l, int i, int n 19 | } 20 | 21 | int main(int argc, char *argv[]) { 22 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3]), atoi(argv[4])); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/28.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int u) { 6 | assert(u > 0); 7 | int x = 0; 8 | int y = 0; 9 | int n = 0; 10 | int i0 = 0; 11 | 12 | while (i0 < u) { 13 | x++; 14 | y++; 15 | i0++; 16 | } 17 | 18 | while (x != n) { 19 | x--; 20 | y--; 21 | } 22 | //%%%traces: int y, int n, int x 23 | //assert(y == n); 24 | } 25 | 26 | int main(int argc, char *argv[]) { 27 | mainQ(atoi(argv[1])); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/30.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(void) { 6 | int i = 0; 7 | int c = 0; 8 | 9 | while (i < 1000) { 10 | c = c + i; 11 | i = i + 1; 12 | } 13 | 14 | //%%%traces: int c, int i 15 | //assert(c >= 0); 16 | } 17 | 18 | int main(int argc, char *argv[]) { 19 | mainQ(); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/32.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int j) { 6 | int i = j; 7 | int k = 100; 8 | int b = 0; 9 | int n = 0; 10 | for (n = 0; n < 2 * k; n++) { 11 | if (b != 0) { 12 | i++; 13 | b = 0; 14 | } else { 15 | j++; 16 | b = 1; 17 | } 18 | } 19 | //%%%traces: int i, int j, int k, int b, int n 20 | //assert(i == j); 21 | } 22 | 23 | int main(int argc, char *argv[]) { 24 | mainQ(atoi(argv[1])); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/34.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | int x = 0; 7 | int y = 0; 8 | int i = 0; 9 | int m = 10; 10 | 11 | while (i < n) { 12 | i++; 13 | x++; 14 | if (i % 2 == 0) y++; 15 | } 16 | //%%%traces: int x, int y, int i, int m 17 | //if (i == m) assert(x == 2 * y); 18 | } 19 | 20 | int main(int argc, char *argv[]) { 21 | mainQ(atoi(argv[1])); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/35.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | int x = 0; 7 | while (x < n) { 8 | x++; 9 | } 10 | 11 | //%%%traces: int x, int n 12 | //if (n > 0) assert(x == n); 13 | } 14 | 15 | int main(int argc, char *argv[]) { 16 | mainQ(atoi(argv[1])); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/37.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n, int u1) { 6 | assert(u1 > 0); 7 | int x = 0; 8 | int m = 0; 9 | 10 | while (x < n) { 11 | if (u1) { 12 | m = x; 13 | } 14 | x = x + 1; 15 | } 16 | 17 | //%%%traces: int n, int m, int x 18 | //if (n > 0) assert(0 <= m && m < n); 19 | } 20 | 21 | int main(int argc, char *argv[]) { 22 | mainQ(atoi(argv[1]), atoi(argv[2])); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /examples/SymInferASE/hola/skip/38.dig.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void mainQ(int n) { 6 | int x = 0; 7 | int y = 0; 8 | int i = 0; 9 | 10 | while (i < n) { 11 | i++; 12 | x++; 13 | if (i % 2 == 0) y++; 14 | } 15 | //%%%traces: int i, int x, int y 16 | //if (i % 2 == 0) assert(x == 2 * y); 17 | } 18 | 19 | int main(int argc, char *argv[]) { 20 | mainQ(atoi(argv[1])); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /examples/SymInferASE/nla/CohenCu.java: -------------------------------------------------------------------------------- 1 | public class CohenCu { 2 | 3 | public static void main (String[] args) { 4 | mainQ_cohencu(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static int mainQ_cohencu(int a) { 8 | int n,x,y,z; 9 | n=0; x=0; y=1; z=6; 10 | 11 | while(true){ 12 | //assert(z == 6*n + 6); 13 | //assert(y == 3*n*n + 3*n + 1); 14 | //assert(x == n*n*n); 15 | //%%%traces: int a, int n, int x, int y, int z 16 | 17 | if(!(n<=a)) break; 18 | 19 | n=n+1; 20 | x=x+y; 21 | y=y+z; 22 | z=z+6; 23 | } 24 | return x; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/nla/Freire1.java: -------------------------------------------------------------------------------- 1 | public class Freire1 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static int mainQ(int a) { 8 | double x = ((double)a)/2.0; 9 | int r = 0; 10 | 11 | 12 | while(true){ 13 | //assert((double)a == 2*x + r*r - r); 14 | //%%%traces: int a, double x, int r 15 | 16 | if (!(x>r)) break; 17 | x = x - r; 18 | r = r + 1; 19 | } 20 | 21 | //assert(r==(int)round(sqrt(a))); 22 | return r; 23 | 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/nla/Ps1.java: -------------------------------------------------------------------------------- 1 | public class Ps1 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static int mainQ(int k){ 8 | assert (k>=0); 9 | int y = 0; 10 | int x = 0; 11 | int c = 0; 12 | 13 | while(true){ 14 | //%%%traces: int x, int y, int k 15 | if (!(c < k)) break; 16 | 17 | c = c + 1; 18 | y = y + 1; 19 | x = x + 1; 20 | } 21 | return x; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /examples/SymInferASE/nla/Ps2.java: -------------------------------------------------------------------------------- 1 | public class Ps2 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static int mainQ(int k){ 8 | assert (k>=0); 9 | assert (k<=30); 10 | 11 | int y = 0; 12 | int x = 0; 13 | int c = 0; 14 | 15 | 16 | while(true){ 17 | //%%%traces: int x, int y, int k 18 | if (!(c < k)) break; 19 | c = c +1 ; 20 | y=y +1; 21 | x=y+x; 22 | } 23 | return x; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /examples/SymInferASE/nla/Ps3.java: -------------------------------------------------------------------------------- 1 | public class Ps3 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static int mainQ(int k){ 8 | assert (k>=0); 9 | assert (k<=30); 10 | 11 | int y = 0; 12 | int x = 0; 13 | int c = 0; 14 | 15 | 16 | while(true){ 17 | //assert(6*x-2*y*y*y-3*y*y-y == 0); 18 | //%%%traces: int x, int y, int k 19 | 20 | if (!(c < k)) break; 21 | c = c +1 ; 22 | y=y +1; 23 | x=y*y+x; 24 | } 25 | return x; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /examples/SymInferASE/nla/Ps4.java: -------------------------------------------------------------------------------- 1 | public class Ps4 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static int mainQ(int k){ 8 | assert (k>=0); 9 | assert (k<=30); 10 | 11 | int y = 0; 12 | int x = 0; 13 | int c = 0; 14 | 15 | while(true){ 16 | //assert(4*x-(y*y*y*y)-2*(y*y*y)-(y*y) == 0); 17 | //%%%traces: int x, int y, int k 18 | 19 | if (!(c < k)) break; 20 | 21 | c = c +1 ; 22 | y=y +1; 23 | x=y*y*y+x; 24 | } 25 | return x; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /examples/SymInferASE/nla/Ps5.java: -------------------------------------------------------------------------------- 1 | public class Ps5 { 2 | 3 | public static void main (String[] args) { 4 | mainQ(Integer.parseInt(args[0])); 5 | } 6 | 7 | public static int mainQ(int k){ 8 | assert (k>=0); 9 | assert (k <= 30); //if too large then will cause overflow 10 | int y = 0; 11 | int x = 0; 12 | int c = 0; 13 | 14 | while(true){ 15 | assert(6*y*y*y*y*y + 15*y*y*y*y+ 10*y*y*y - 30*x - y == 0); 16 | //printf("%d %d\n", x,y); 17 | //%%%traces: int x, int y, int k 18 | 19 | if (!(c < k)) break; 20 | c = c +1 ; 21 | y=y +1; 22 | x=y*y*y*y+x; 23 | } 24 | return x; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /examples/SymInferASE/nla/bytecode/Test1.java: -------------------------------------------------------------------------------- 1 | public class Test1 { 2 | public static void vtrace1(int x, int y, int z, int b, int c){} 3 | public static void main (String[] args){} 4 | 5 | public static int mainQ(int x){ 6 | int y = 0; 7 | int z = 0; 8 | int c = 0; 9 | int b = 0; 10 | 11 | while(true){ 12 | vtrace1(x, y, z, b, c); 13 | if (!(c < x)) break; 14 | 15 | c = c + 1; 16 | y = y + 1; 17 | if (x == 7) z = z+1; 18 | z = z + 1; 19 | } 20 | return x; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /examples/acsl/c/distance.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vtrace(int a, int b, int result){} 5 | 6 | int mainQ(int a, int b) { 7 | int result; 8 | if (a > b) { 9 | result = a-b; 10 | } 11 | else{ 12 | result = b-a; 13 | } 14 | vtrace(a,b,result); 15 | return result; 16 | } 17 | 18 | void main(int argc, char **argv){ 19 | mainQ(atoi(argv[1]), atoi(argv[2])); 20 | } 21 | 22 | /*@ //requires \nothing; 23 | requires \true; 24 | assigns \nothing; 25 | ensures \result == \max(a, b) - \min(a, b); 26 | */ 27 | -------------------------------------------------------------------------------- /examples/acsl/c/factorial.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vtrace(int i, int f){} 5 | 6 | long mainQ(int i) 7 | { 8 | long f = 1; 9 | /*@ loop invariant 0 <= i; 10 | loop assigns f, i; 11 | loop variant i; 12 | */ 13 | while (i) { 14 | f *= i--; 15 | } 16 | 17 | vtrace(i, f); 18 | return f; 19 | } 20 | 21 | void main(int argc, char **argv){ 22 | mainQ(atoi(argv[1])); 23 | } 24 | 25 | /*@ requires factorial(i) <= SPEC_ULONG_MAX; 26 | assigns \nothing; 27 | ensures \result == factorial(i); 28 | */ 29 | -------------------------------------------------------------------------------- /examples/acsl/c/factorial_rec.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int i){} 5 | void vtrace(int q, int r, int a, int b, int x, int y){} 6 | 7 | long mainQ(int i) 8 | { 9 | vassume(i<=20); 10 | if (i == 0) { 11 | return 1; 12 | } else { 13 | 14 | 15 | return factorial_rec(i - 1) * i; 16 | } 17 | } 18 | 19 | void main(int argc, char **argv){ 20 | mainQ(atoi(argv[1])); 21 | } 22 | 23 | /*@ requires i <= 20; 24 | decreases i; 25 | assigns \nothing; 26 | ensures factorial_ind(i, \result); 27 | */ 28 | -------------------------------------------------------------------------------- /examples/acsl/c/fib_rec.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vtrace(int i){} 5 | 6 | int mainQ(int i) 7 | { 8 | 9 | if (i == 0 || i == 1) return i; 10 | if (i == -1) return 1; 11 | 12 | if (i > 0) { 13 | return fib_rec(i - 1) + fib_rec(i - 2); 14 | } else { 15 | return fib_rec(i + 2) - fib_rec(i + 1); 16 | } 17 | } 18 | 19 | void main(int argc, char **argv){ 20 | mainQ(atoi(argv[1])); 21 | } 22 | 23 | /*@ requires SPEC_INT_MIN <= fib(i) <= SPEC_INT_MAX; 24 | decreases \abs(i); 25 | assigns \nothing; 26 | ensures \result == fib(i); 27 | */ 28 | -------------------------------------------------------------------------------- /examples/acsl/c/gcd_rec.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int q, int r, int a, int b, int x, int y){} 6 | 7 | int mainQ(int x1, int x2) 8 | { 9 | vassume(x1>0); 10 | if (x2 == 0) 11 | return x1; 12 | 13 | return gcd_rec(x2, x1 % x2); 14 | } 15 | 16 | void main(int argc, char **argv){ 17 | mainQ(atoi(argv[1]), atoi(argv[2])); 18 | } 19 | 20 | /*@ requires x1 > 0; 21 | decreases x2; 22 | assigns \nothing; 23 | ensures is_gcd(\result, x1, x2); 24 | ensures \result == gcd(x1, x2); 25 | */ 26 | -------------------------------------------------------------------------------- /examples/examples/Chanh1.java: -------------------------------------------------------------------------------- 1 | public class Chanh1 { 2 | public static void vtrace1(int x, int n){} 3 | public static void vtrace2(int x, int n){} 4 | public static void main (String[] args) {} 5 | public static int mainQ(int x, int n){ 6 | assert (n>=0); 7 | //assert (x>0); 8 | 9 | while(true){ 10 | if(!(x != 0 && n>0)) break; 11 | vtrace1(x,n); 12 | x++; 13 | n--; 14 | 15 | } 16 | //vtrace2(x,n); 17 | //n = 0 & x >= 1 18 | return 0; 19 | } 20 | } 21 | 22 | 23 | /* 24 | 25 | x > 0 <=> non-term 26 | 27 | conj of oct 28 | 29 | x - y >= c0 30 | 31 | precond(inps) => nonterm 32 | precond(ijnps) => term 33 | 34 | */ 35 | -------------------------------------------------------------------------------- /examples/examples/CohenDivFake.java: -------------------------------------------------------------------------------- 1 | public class CohenDivFake { 2 | public static void vtrace0(int q, int r, int a, int b, int x, int y){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int q, int r, int a, int b, int x, int y){ 5 | 6 | if(a*y - b == 0 && q*y + r - x == 0 && 7 | -r <= 0 && -a <= 0 && -x <= -1 && 8 | r - x <= 0 && a - q <= 0 && q - x <= 0 && 9 | a - b <= 0 && b - x <= 0 && -a - y <= -1){ 10 | vtrace0(q, r, a, b, x, y); 11 | } 12 | return 0; 13 | } 14 | } 15 | 16 | -------------------------------------------------------------------------------- /examples/examples/Ex0.java: -------------------------------------------------------------------------------- 1 | public class Ex0 { 2 | public static void vtrace0(int m, int n){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int m, int n){ 5 | if (m >= 3 && m <= 200 && n >= 1 && n + 2*m == 80){ 6 | vtrace0(m,n); 7 | } 8 | return 0; 9 | } 10 | } 11 | 12 | -------------------------------------------------------------------------------- /examples/examples/Ex1.java: -------------------------------------------------------------------------------- 1 | public class Ex1 { 2 | public static void vtrace1_post(int m, int tCtr){} 3 | public static void vtrace0(int m, int n){} 4 | public static void main (String[] args) {} 5 | public static int mainQ(int m, int n){ 6 | assert (n >= 1); 7 | // if (m > 1 && n <= 20 && 2*n*n + 3*m == 62){ 8 | // vtrace0(m,n); 9 | // } 10 | 11 | int tCtr = 0; 12 | if (m < 0){ 13 | tCtr = -10; 14 | } 15 | else if (m == 0){ 16 | tCtr = 5; 17 | } 18 | else{ // m > 0 19 | tCtr = m + 7; 20 | } 21 | vtrace1_post(m, tCtr); 22 | 23 | return 0; 24 | } 25 | } 26 | 27 | -------------------------------------------------------------------------------- /examples/examples/Ex2.java: -------------------------------------------------------------------------------- 1 | public class Ex2 { 2 | public static void vtrace1_post(int m, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int m){ 5 | int tCtr = 0; 6 | if (m < 0){ 7 | tCtr = -5; 8 | } 9 | else if (m == 0){ 10 | tCtr = 2; 11 | } 12 | else{ 13 | tCtr = m + 5; 14 | } 15 | vtrace1_post(m, tCtr); 16 | 17 | return 0; 18 | } 19 | } 20 | 21 | -------------------------------------------------------------------------------- /examples/examples/Ex3.java: -------------------------------------------------------------------------------- 1 | public class Ex3 { 2 | public static void vtrace1_post(int m, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int m){ 5 | int tCtr = 0; 6 | if (m <= 7){ 7 | tCtr = -5; 8 | } 9 | else{ 10 | tCtr = m + 5; 11 | } 12 | vtrace1_post(m, tCtr); 13 | 14 | return 0; 15 | } 16 | } 17 | 18 | -------------------------------------------------------------------------------- /examples/examples/Ex4.java: -------------------------------------------------------------------------------- 1 | public class Ex4 { 2 | public static void vtrace1_post(int M, int N, int P, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int M, int N, int P){ 5 | assert (0 <= M); 6 | assert (0 <= N); 7 | assert (0 <= P); 8 | 9 | int tCtr = 0; 10 | if (N == 0){ 11 | tCtr = 0; 12 | } 13 | else if (N <= P){ 14 | tCtr = P + M + 1; 15 | } 16 | else if (N > P){ // P - N < 0 ; -N + P < 0 17 | tCtr = N - M*(P-N); 18 | } 19 | vtrace1_post(M, N, P, tCtr); 20 | 21 | return 0; 22 | } 23 | } 24 | 25 | -------------------------------------------------------------------------------- /examples/examples/Ex5.java: -------------------------------------------------------------------------------- 1 | public class Ex5 { 2 | public static void vtrace1_post(int M, int N, int P, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int M, int N, int P){ 5 | assert (0 <= M); 6 | assert (0 <= N); 7 | assert (0 <= P); 8 | 9 | int tCtr = 0; 10 | if (N == 0 || M == 0 || P == 0){ 11 | tCtr = 0; 12 | } 13 | else if (N <= P && M > 0){ 14 | tCtr = P + M + 1; 15 | } 16 | // else if (N > P || M == 0){ 17 | // tCtr = N - M*(P-N); 18 | // } 19 | vtrace1_post(M, N, P, tCtr); 20 | 21 | return 0; 22 | } 23 | } 24 | 25 | -------------------------------------------------------------------------------- /examples/examples/Ex6.java: -------------------------------------------------------------------------------- 1 | public class Ex6 { 2 | public static void vtrace1_post(int M, int N, int P, int tCtr){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int M, int N, int P){ 5 | assert (0 <= M); 6 | assert (0 <= N); 7 | assert (0 <= P); 8 | 9 | int tCtr = 0; 10 | if (N == 0 || M == 0 || P == 0){ 11 | tCtr = 5; 12 | vtrace1_post(M, N, P, tCtr); 13 | } 14 | 15 | 16 | return 0; 17 | } 18 | } 19 | 20 | -------------------------------------------------------------------------------- /examples/examples/ExUnreach.java: -------------------------------------------------------------------------------- 1 | public class ExUnreach { 2 | //public static void vtrace0(int m){} 3 | public static void vtrace1(int m){} 4 | public static void main (String[] args) {} 5 | public static int mainQ(int m){ 6 | assert(m >= 1); 7 | //if (m < 0){ //not reachable 8 | // vtrace0(m); 9 | //} 10 | //else{ 11 | //vtrace1(m); 12 | //} 13 | vtrace1(m); 14 | return 0; 15 | } 16 | } 17 | 18 | -------------------------------------------------------------------------------- /examples/examples/MP.java: -------------------------------------------------------------------------------- 1 | public class MP { 2 | public static void vtrace1(int x, int y, int z){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int x, int y){ 5 | int z = 0; 6 | if (x >= y){ 7 | z = x; 8 | } 9 | else{ 10 | z = y; 11 | } 12 | 13 | //if(x>=y, x==z, y==z) 14 | vtrace1(x, y, z); 15 | return 0; 16 | } 17 | } 18 | 19 | -------------------------------------------------------------------------------- /examples/examples/MP1.java: -------------------------------------------------------------------------------- 1 | public class MP1 { 2 | public static void vtrace1(int x, int y) { 3 | } 4 | 5 | public static void vtrace2(int x, int y) { 6 | } 7 | 8 | public static void vtrace3(int x, int y, int z) { 9 | } 10 | 11 | public static void main(String[] args) { 12 | } 13 | 14 | public static int mainQ(int x, int y) { 15 | int z = 5; 16 | if (3 <= x && x <= 9) { 17 | vtrace1(x, y); 18 | } 19 | if (x<=y){ 20 | vtrace2(x,y); 21 | } 22 | if (y<=x){ 23 | vtrace3(x,y,z); 24 | } 25 | 26 | return 0; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /examples/examples/MP2.java: -------------------------------------------------------------------------------- 1 | public class MP2 { 2 | public static void vtrace1(int x, int y) { 3 | } 4 | 5 | public static void vtrace2(int x, int y) { 6 | } 7 | 8 | public static void vtrace3(int x, int y, int z) { 9 | } 10 | 11 | public static void main(String[] args) { 12 | } 13 | 14 | public static int mainQ(int x, int y) { 15 | int z = 5; 16 | if (-x - y <= 8){ 17 | vtrace1(x, y); 18 | } 19 | return 0; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /examples/examples/MP_long.java: -------------------------------------------------------------------------------- 1 | public class MP_long { 2 | public static void vtrace1(int x, int y, int a, int b){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(int x, int y){ 5 | int a = 0; 6 | int b = 0; 7 | if (x >= y){ 8 | a = x; 9 | } 10 | else{ 11 | a = y; 12 | } 13 | 14 | //if(x>=y, x==z, y==z) 15 | vtrace1(x, y, a,b); 16 | return 0; 17 | } 18 | } 19 | 20 | -------------------------------------------------------------------------------- /examples/examples/NoInput.java: -------------------------------------------------------------------------------- 1 | public class NoInput { 2 | public static void vtrace1(int x, int y, int z){} 3 | public static void main (String[] args) {} 4 | public static int mainQ(){ 5 | int x = 0; 6 | int y = 0; 7 | int z = 0; 8 | int ctr = 0; 9 | while(ctr < 20){ 10 | ctr++; 11 | x++; 12 | y = 2*x; 13 | vtrace1(x, y, z); 14 | } 15 | return 0; 16 | } 17 | } 18 | 19 | -------------------------------------------------------------------------------- /examples/examples/OddEven2.java: -------------------------------------------------------------------------------- 1 | //swap: a += (b - (b = a)); 2 | public class OddEven2 { 3 | public static void vtrace1(int x0, int x1, int t0, int t1){} 4 | 5 | public static void main (String[] args) {} 6 | 7 | public static void mainQ(int t0, int t1) { 8 | int x0 = t0; 9 | int x1 = t1; 10 | if (x0 >= x1){ 11 | x0 += (x1 - (x1 = x0)); 12 | } 13 | 14 | assert(x1 >= x0); 15 | vtrace1(x0,x1,t0,t1); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /examples/examples/chanh.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int X){} 6 | void vtrace2(int x, int X, int i){} 7 | 8 | void mainQ(int X) { 9 | int i = 0; 10 | int x = X; 11 | while (x > 0) { 12 | x--; 13 | i++; 14 | } 15 | 16 | if(i < 10){ 17 | vtrace1(X); 18 | } 19 | } 20 | 21 | 22 | void main(int argc, char *argv[]) { 23 | mainQ(atoi(argv[1])); 24 | } 25 | -------------------------------------------------------------------------------- /examples/examples/cohencu_1loc.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vtrace1(int a, int n, int x, int y, int z){} 5 | 6 | int mainQ(int a){ 7 | int n,x,y,z; 8 | 9 | n=0; x=0; y=1; z=6; 10 | 11 | while(1){ 12 | //assert(z == 6*n + 6); 13 | //assert(y == 3*n*n + 3*n + 1); 14 | //assert(x == n*n*n); 15 | vtrace1(a, n, x, y, z); 16 | 17 | if(!(n<=a)) break; 18 | //write_int(x); 19 | 20 | n=n+1; 21 | x=x+y; 22 | y=y+z; 23 | z=z+6; 24 | } 25 | return x; 26 | } 27 | 28 | 29 | void main(int argc, char **argv){ 30 | mainQ(atoi(argv[1])); 31 | } 32 | 33 | -------------------------------------------------------------------------------- /examples/examples/ex0.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int m){} 6 | 7 | void mainQ(int m, int n) { 8 | vassume(n > 9); 9 | if (2*m == 18){ 10 | vtrace1(m); 11 | } 12 | } 13 | 14 | void main(int argc, char *argv[]) { 15 | mainQ(atoi(argv[1]), atoi(argv[2])); 16 | } 17 | -------------------------------------------------------------------------------- /examples/examples/ex1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace(int m, int n){} 6 | 7 | void mainQ(int m, int n) { 8 | if (m >= 3 && m <= 200 && n >= 1 && n + 2*m == 80){ 9 | //if (m >= 5){ 10 | vtrace(m,n); 11 | } 12 | } 13 | 14 | void main(int argc, char *argv[]) { 15 | mainQ(atoi(argv[1]), atoi(argv[2])); 16 | } 17 | -------------------------------------------------------------------------------- /examples/examples/ex2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1_post(int m, int tCtr){} 6 | 7 | void mainQ(int m) { 8 | int tCtr = 0; 9 | if (m < 0){ 10 | tCtr = -5; 11 | } 12 | else if (m == 0){ 13 | tCtr = 2; 14 | } 15 | else{ 16 | tCtr = m + 5; 17 | } 18 | vtrace1_post(m, tCtr); 19 | } 20 | 21 | void main(int argc, char *argv[]) { 22 | mainQ(atoi(argv[1])); 23 | } 24 | -------------------------------------------------------------------------------- /examples/examples/ex4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1_post(int M, int N, int P, int tCtr){} 6 | 7 | void mainQ(int M, int N, int P) { 8 | vassume (0 <= M); 9 | vassume (0 <= N); 10 | vassume (0 <= P); 11 | 12 | int tCtr = 0; 13 | if (N == 0){ 14 | tCtr = 0; 15 | } 16 | else if (N <= P){ 17 | tCtr = P + M + 1; 18 | } 19 | else if (N > P){ // P - N < 0 ; -N + P < 0 20 | tCtr = N - M*(P-N); 21 | } 22 | vtrace1_post(M, N, P, tCtr); 23 | 24 | } 25 | 26 | void main(int argc, char *argv[]) { 27 | mainQ(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); 28 | } 29 | -------------------------------------------------------------------------------- /examples/examples/example.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace1(int i, int M){} 6 | void vtrace2(int i, int M){} 7 | 8 | void mainQ(int M) { 9 | vassume (0 <= M); 10 | int i = 0; 11 | while(1){ 12 | vtrace1(i, M); 13 | if (!(i < M))break; 14 | i++; 15 | } 16 | vtrace2(i, M); 17 | 18 | } 19 | 20 | void main(int argc, char *argv[]) { 21 | mainQ(atoi(argv[1])); 22 | } 23 | -------------------------------------------------------------------------------- /examples/examples/linear.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | void vtrace0(int x, int y, int n){} 6 | void vtrace1(int x, int y, int n){} 7 | void mainQ(int n) { 8 | vassume(n >= 0); //precond 9 | int y = 0; 10 | int x = n; 11 | while(1){ 12 | vtrace0(x,y,n); 13 | if(!(x>0)) break; 14 | x -= 1; 15 | y += 1; 16 | } 17 | 18 | vtrace1(x,y,n); 19 | //assert(y==n);//postcond 20 | } 21 | 22 | void main(int argc, char *argv[]) { 23 | mainQ(atoi(argv[1])); 24 | } 25 | -------------------------------------------------------------------------------- /examples/miscs/univariate_poly.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void vassume(int b) {} 4 | void vtrace(int f_x, int f_x1, int f_x2, int x1, int x2) {} 5 | 6 | // f(x) = x(x + 1) 7 | int F(int x) { return x * x + x; } 8 | 9 | void mainQ(int x1, int x2) { 10 | int x = x1 + x2; 11 | int f_x = F(x); 12 | int f_x1 = F(x1); 13 | int f_x2 = F(x2); 14 | 15 | vtrace(f_x, f_x1, f_x2, x1, x2); 16 | // goal : x1^2 + x2^2 + 2x1x2 + x1 + x2 == x^2 + x 17 | } 18 | 19 | void main(int argc, char *argv[]) { 20 | mainQ(atoi(argv[1]), atoi(argv[2])); 21 | } 22 | -------------------------------------------------------------------------------- /examples/t2a.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void vassume(int b) {} 4 | void vtrace(int g, int h) {} 5 | 6 | // f(x) = x(x + 1) 7 | int F(int x) { return x * x; } 8 | 9 | void mainQ(int x1, int x2) { 10 | int x = x1 + x2; 11 | int y = x1 - x2; 12 | int f_x = F(x); 13 | int f_y = F(y); 14 | int f_x1 = F(x1); 15 | int f_x2 = F(x2); 16 | 17 | vtrace(f_x*f_x - 2*f_y*f_x + f_y*f_y, f_x1*f_x2); // <--------------------------HERE 18 | } 19 | 20 | void main(int argc, char *argv[]) { 21 | mainQ(atoi(argv[1]), atoi(argv[2])); 22 | } -------------------------------------------------------------------------------- /examples/test1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void vassume(int b){} 4 | void vtrace2(int x, int y, int z, int it){} 5 | 6 | int mainQ(int x, int y){ 7 | vassume(x >= 1 ); 8 | 9 | int z = 0; 10 | int x1 = x; 11 | 12 | int it = 1; 13 | while (it < 28){ 14 | it++; 15 | 16 | } 17 | 18 | 19 | vtrace2(x, y, z, it); //postconditions 20 | return x; 21 | } 22 | 23 | void main(int argc, char **argv){ 24 | mainQ(atoi(argv[1]), atoi(argv[2])); 25 | } 26 | 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /examples/traces/congruences1.csv: -------------------------------------------------------------------------------- 1 | vtrace1; I x; 2 | vtrace1; 1 3 | vtrace1; 4 4 | vtrace1; 7 5 | vtrace1; 10 6 | vtrace1; 13 7 | vtrace1; 16 8 | -------------------------------------------------------------------------------- /examples/traces/ex.csv: -------------------------------------------------------------------------------- 1 | # y=2*x + 3 2 | # n = 20; ls = [random.randrange(-10,10) for _ in range(n)] ; print('\n'.join(["{};{}".format(x,2*x+3) for x in ls])) 3 | vtrace1; I x; I y 4 | vtrace1; 3;9 5 | vtrace1; -2;-1 6 | vtrace1; -9;-15 7 | vtrace1; -3;-3 8 | vtrace1; 7;17 9 | vtrace1; 8;19 10 | vtrace1; -1;1 11 | vtrace1; 7;17 12 | vtrace1; -8;-13 13 | vtrace1; -3;-3 14 | vtrace1; -3;-3 15 | vtrace1; 1;5 16 | vtrace1; 1;5 17 | vtrace1; 8;19 18 | vtrace1; -4;-5 19 | vtrace1; 9;21 20 | vtrace1; 0;3 21 | vtrace1; -7;-11 22 | vtrace1; -7;-11 23 | vtrace1; 0;3 24 | -------------------------------------------------------------------------------- /examples/traces/ex2.csv: -------------------------------------------------------------------------------- 1 | x,y 2 | 1,2 3 | 3,4 4 | -------------------------------------------------------------------------------- /examples/traces/ex4.csv: -------------------------------------------------------------------------------- 1 | vtrace1; I x 2 | vtrace1; 2 3 | # vtrace1; -7; -14 4 | -------------------------------------------------------------------------------- /examples/traces/ex5.csv: -------------------------------------------------------------------------------- 1 | # y=x^3 + x^2 + 2*x + 7 2 | # >>> import random; n = 20; ls = [random.randrange(-10,10) for _ in range(n)] ; print('\n'.join(["{};{}".format(x, x*x*x + x*x + 2*x + 7) for x in ls])) 3 | vtrace1; I x; I y 4 | vtrace1;3;49 5 | vtrace1;9;835 6 | vtrace1;-4;-49 7 | vtrace1;2;23 8 | vtrace1;-8;-457 9 | vtrace1;4;95 10 | vtrace1;5;167 11 | -------------------------------------------------------------------------------- /examples/traces/ex_float.csv: -------------------------------------------------------------------------------- 1 | # import random 2 | # n = 20 3 | # ls = [round(random.uniform(-10, 10), 1) for _ in range(n)] 4 | # print('\n'.join(["{};{}".format(x, 2*x+3) for x in ls])) 5 | vtrace1; F x; F y 6 | vtrace1; 7.5;18.0 7 | # vtrace1; -4.4;-5.800000000000001 8 | vtrace1; -7.9;-12.8 9 | vtrace1; 0.1;3.2 10 | vtrace1; 0.1;3.2 11 | vtrace1; -9.6;-16.2 12 | vtrace1; -2.9;-2.8 13 | vtrace1; 3.6;10.2 14 | vtrace1; -4.3;-5.6 15 | vtrace1; 6.6;16.2 16 | vtrace1; 7.0;17.0 17 | vtrace1; 6.7;16.4 18 | vtrace1; 3.0;9.0 19 | vtrace1; 5.7;14.4 20 | # vtrace1; -1.4;0.20000000000000018 21 | vtrace1; -3.0;-3.0 22 | vtrace1; 0.7;4.4 23 | vtrace1; 0.2;3.4 24 | vtrace1; 0.9;4.8 25 | vtrace1; -3.7;-4.4 -------------------------------------------------------------------------------- /examples/traces/paper_nested.csv: -------------------------------------------------------------------------------- 1 | # 1: A[i1] = B[-2*i1 + 5] 2 | vtrace1; array A; array B; array C 3 | vtrace1; [7,1,-3]; [1,-3,5,1,0,7,1]; [8,5,6,6,2,1,4] 4 | vtrace1; [7,1,-3]; [1,-3,5,1,0,7,1]; [1,7,8,8,9,10,3] 5 | 6 | 7 | -------------------------------------------------------------------------------- /examples/traces/paper_nested2.csv: -------------------------------------------------------------------------------- 1 | # 0: A[i1] = B[C[2*i1 + 1]] 2 | # 1: A[i1] = B[-2*i1 + 5] 3 | vtrace1; array A; array B; array C 4 | vtrace1; [7,1,-3]; [1,-3,5,1,0,7,1]; [8,5,6,6,2,1,4] 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /examples/traces/test1.tcs: -------------------------------------------------------------------------------- 1 | vtrace1: I x, I y, I z 2 | vtrace1: 0, 4, 0 3 | vtrace1: 0, 4, 1 4 | vtrace1: 0, 4, 2 5 | 6 | vtrace1: 0, 4, 3 7 | vtrace1: 0, 4, 4 8 | vtrace1: 0, 4, 5 9 | 10 | 11 | vtrace1: 0, 4, 6 12 | vtrace1: 0, 4, 7 13 | vtrace1: 0, 4, 8 -------------------------------------------------------------------------------- /examples/transform/simple.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void vassume(int b){} 5 | 6 | int mainQ(int x, int y){ 7 | vassume(x >= 1 && y >= 1); 8 | 9 | return 0; 10 | } 11 | 12 | void main(int argc, char **argv){ 13 | mainQ(atoi(argv[1]), atoi(argv[2])); 14 | } 15 | 16 | 17 | -------------------------------------------------------------------------------- /examples/transform/simple.c.instr.c: -------------------------------------------------------------------------------- 1 | #include 2 | -------------------------------------------------------------------------------- /src/algebraicaxioms/java/JParser.java: -------------------------------------------------------------------------------- 1 | import com.github.javaparser.JavaParser; 2 | import com.github.javaparser.ast.CompilationUnit; 3 | 4 | import java.io.FileInputStream; 5 | 6 | public class JParser{ 7 | 8 | public static void main(String[] args) throws Exception{ 9 | if (args.length < 1){ 10 | System.err.println("Enter Java filename .."); 11 | System.exit(1); 12 | } 13 | String javaFile = args[0]; 14 | 15 | System.out.println("Parsing " + javaFile); 16 | FileInputStream in = new FileInputStream(javaFile); 17 | CompilationUnit cu = JavaParser.parse(in); 18 | System.out.println(cu.toString()); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/algebraicaxioms/java/README.txt: -------------------------------------------------------------------------------- 1 | javac -cp .:/home/tnguyen/Src/Devel/LIBS/javaparser-javaparser-parent-2.5.0/javaparser-core/target/classes MethodPrinter.java 2 | javac -cp .:/home/tnguyen/Src/Devel/LIBS/javaparser-javaparser-parent-2.5.0/javaparser-core/target/classes MethodPrinter 3 | -------------------------------------------------------------------------------- /src/algebraicaxioms/java/examples/StackExample.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class StackExample{ 4 | public static void main(String args[]){ 5 | // creating stack 6 | Stack st = new Stack(); 7 | Stack stRef = st; 8 | 9 | st.push("Java"); 10 | st.push("Source"); 11 | stRef.push("code"); 12 | 13 | // removing top object 14 | System.out.println("Removed object is: "+st.pop()); 15 | 16 | // elements after remove 17 | System.out.println("Elements after remove: "+st); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/algebraicaxioms/java/old/Arg.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class Arg extends Term{ 4 | int id; 5 | 6 | Arg(int mid, List typs){ 7 | super(typs); 8 | assert(id >= 0); 9 | id = mid; 10 | } 11 | 12 | Arg(List typs){this(-1, typs);} 13 | 14 | //copy ctor 15 | Arg(Arg a){this(a.id, new ArrayList(a.typs));} 16 | 17 | 18 | public String toString(){ 19 | String s = get_otyp(); 20 | if (is_instantiated()) s += "_" + id; 21 | return s; 22 | } 23 | public boolean is_instantiated(){return id > -1;} 24 | 25 | public int get_id(){return id;} 26 | 27 | 28 | } 29 | -------------------------------------------------------------------------------- /src/algebraicaxioms/java/old/Drivers.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class Drivers{ 3 | public static void main(String args[]){ 4 | 5 | Node pop = new Node("pop"); 6 | 7 | Node push = new Node("push"); 8 | 9 | 10 | System.out.println(pop); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/algebraicaxioms/java/old/Term.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public abstract class Term{ 4 | 5 | Listtyps; 6 | 7 | Term(List mtyps){ 8 | assert(typs.size() >= 1); 9 | typs = mtyps; 10 | } 11 | 12 | public String get_otyp(){return typs.get(typs.size() - 1);} 13 | abstract boolean is_instantiated(); 14 | } 15 | 16 | 17 | 18 | 19 | -------------------------------------------------------------------------------- /src/algebraicaxioms/python/examples/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dynaroars/dig/7e1ebec4899d7687607e4fdd4c284dd835d68eec/src/algebraicaxioms/python/examples/__init__.py -------------------------------------------------------------------------------- /src/algebraicaxioms/python/examples/string.py: -------------------------------------------------------------------------------- 1 | import typing 2 | 3 | lang = "Java" 4 | 5 | def fake(s:str) -> str: pass 6 | fake_def = (fake, 'fake', []) 7 | def concat(s:str, x:str) -> str:pass 8 | concat_def = (concat, 'concat', []) 9 | 10 | def isEmpty(s:str) -> bool: pass 11 | isEmpty_def = (isEmpty, 'isEmpty', []) 12 | 13 | 14 | def slength(s:str) -> int: pass 15 | slength_def = (slength, 'length', []) 16 | 17 | defs = [fake_def, isEmpty_def] 18 | 19 | 20 | -------------------------------------------------------------------------------- /src/algebraicaxioms/python/src/JString.py: -------------------------------------------------------------------------------- 1 | import mytyp 2 | 3 | class MyStr(mytyp.PyTyp): 4 | ptyp = str 5 | jtyp = "String" 6 | 7 | @classmethod 8 | def createNew(cls, vname, vkey, d): 9 | return cls.createNew_new(vname, vkey, d) 10 | 11 | 12 | lang = "Java" 13 | 14 | def concat(s:str, x:str) -> str:pass 15 | concat_def = (concat, 'concat', []) 16 | 17 | def isEmpty(s:str) -> bool: pass 18 | isEmpty_def = (isEmpty, 'isEmpty', []) 19 | 20 | 21 | def slength(s:str) -> int: pass 22 | slength_def = (slength, 'length', []) 23 | 24 | defs = [isEmpty_def, slength_def] 25 | 26 | 27 | -------------------------------------------------------------------------------- /src/algebraicaxioms/python/src/Test1.java: -------------------------------------------------------------------------------- 1 | // any_0 = lpop(any_list_0) 2 | // any_00 = 5; 3 | // any_list_00 = [7]; 4 | // lpop_ret0 = pop(any_list_00); 5 | // eq_ret0 = any_00 == lpop_ret0; 6 | 7 | 8 | import java.util.*; 9 | public class Test1{ 10 | @SuppressWarnings("unchecked") 11 | public static void main(String args[]){ 12 | if (f1() || f2()){ 13 | System.out.println("gh"); 14 | } 15 | } 16 | 17 | private static boolean f1(){ 18 | System.out.println("f1"); 19 | return true; 20 | } 21 | private static boolean f2(){ 22 | System.out.println("f1"); 23 | return true; 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /src/algebraicaxioms/python/src/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dynaroars/dig/7e1ebec4899d7687607e4fdd4c284dd835d68eec/src/algebraicaxioms/python/src/__init__.py -------------------------------------------------------------------------------- /src/algebraicaxioms/python/src/config.py: -------------------------------------------------------------------------------- 1 | import vu_common as CM 2 | 3 | logger_level = CM.VLog.DEBUG 4 | -------------------------------------------------------------------------------- /src/algebraicaxioms/python/src/java/Perms.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class Perms{ 4 | private static final List emptyList = new ArrayList(); 5 | 6 | public static List gen_args(int n){ 7 | if (n <= 0){ 8 | return emptyList; 9 | } 10 | 11 | //int len = 12 | return emptyList; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/algebraicaxioms/python/src/learn/MyLinkedList.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class MyLinkedList{ 3 | @SuppressWarnings("unchecked") 4 | public static void main(String args[]){ 5 | LinkedList ll = new LinkedList(); 6 | ll.add("F"); 7 | ll.add("B"); 8 | ll.add("D"); 9 | 10 | ll.addLast("Z"); 11 | ll.addFirst("A"); 12 | ll.add(1, "A2"); 13 | 14 | System.out.println("ll " + ll); 15 | 16 | System.out.println("ll " + ll.removeLast()); 17 | 18 | } 19 | 20 | 21 | } 22 | -------------------------------------------------------------------------------- /src/algebraicaxioms/python/src/learn/MyStringTest.java: -------------------------------------------------------------------------------- 1 | // any_0 = lpop(any_list_0) 2 | // any_00 = 5; 3 | // any_list_00 = [7]; 4 | // lpop_ret0 = pop(any_list_00); 5 | // eq_ret0 = any_00 == lpop_ret0; 6 | 7 | 8 | import java.util.*; 9 | public class MyStringTest{ 10 | @SuppressWarnings("unchecked") 11 | public static void main(String args[]){ 12 | String s = "Hello World"; 13 | System.out.println(s.length()); 14 | System.out.println(s.isEmpty()); 15 | } 16 | 17 | 18 | } 19 | -------------------------------------------------------------------------------- /src/algebraicaxioms/python/src/t.py: -------------------------------------------------------------------------------- 1 | import alg_miscs 2 | print(alg_miscs.gen_parts(range(2), 1, False)) 3 | print(len(alg_miscs.gen_parts(range(10), 4, False))) 4 | # print(len(alg_miscs.gen_parts(range(3), 2, False))) 5 | # print(len(alg_miscs.gen_parts(range(3), 3, False))) 6 | # print(alg_miscs.gen_parts(range(3), 3, False)) 7 | # print(len(alg_miscs.gen_parts(range(4), 2, False))) 8 | #print(rs) 9 | 10 | -------------------------------------------------------------------------------- /src/algebraicaxioms/python/src/todo: -------------------------------------------------------------------------------- 1 | 0. any_0 = lpop(lpush(any_list_0,any_0)) 2 | 1. any_0 = lpeek(lpush(any_list_0,any_0)) 3 | 2. lsearch(any_list_0,any_0) = lsearch(lpop(lpush(any_list_0,any_1)),any_0) @wrong 4 | 3. lpop(lpush(any_list_0,any_0)) = lpeek(lpush(any_list_1,any_0)) #wrong 5 | 4. lempty(lpop(lpush(any_list_0,any_0))) = lempty(any_list_0) #wrong ... actually OK 6 | -------------------------------------------------------------------------------- /src/beta/beta.py: -------------------------------------------------------------------------------- 1 | from functools import reduce 2 | from math import gcd 3 | 4 | 5 | def check(X, n, b): 6 | for v in X: 7 | if v % n != b: 8 | raise RuntimeError(f'n={n} b={b} X={X}') 9 | 10 | 11 | def found(X, n): 12 | b = X[0] % n 13 | print(f'n={n} b={b}') 14 | check(X, n, b) 15 | 16 | 17 | def solve(X)->tuple: 18 | assert(X), X 19 | print(f'X={X}') 20 | Y = [X[0] - v for v in X] 21 | print('Y', Y) 22 | g = reduce(gcd, Y) 23 | print('g', g) 24 | found(X, g) 25 | 26 | 27 | 28 | solve([4, 0, 8, 12, 16, 19]) 29 | # solve([6, 11, 16, 1, 21]) 30 | -------------------------------------------------------------------------------- /src/beta/t.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dynaroars/dig/7e1ebec4899d7687607e4fdd4c284dd835d68eec/src/beta/t.c -------------------------------------------------------------------------------- /src/beta/t.py: -------------------------------------------------------------------------------- 1 | import sympy 2 | import helpers.miscs 3 | import pdb 4 | DBG = pdb.set_trace 5 | 6 | 7 | a,b,c,x = sympy.symbols('a b c x') 8 | eqt = sympy.Eq(c**2-b,100) 9 | print(helpers.miscs.Miscs.get_vars(eqt)) 10 | DBG() -------------------------------------------------------------------------------- /src/infer/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dynaroars/dig/7e1ebec4899d7687607e4fdd4c284dd835d68eec/src/infer/__init__.py -------------------------------------------------------------------------------- /src/java/Makefile: -------------------------------------------------------------------------------- 1 | JFLAGS = -cp asm-all-5.2.jar 2 | JAVAC = /home/SHARED/Devel/JAVA/java8/bin/javac 3 | default: 4 | $(JAVAC) $(JFLAGS) MyConst.java PrintInstr.java JPFInstr.java Instrument.java CollectInfo.java 5 | 6 | classes: $(CLASSES:.java=.class) 7 | 8 | clean: 9 | $(RM) *.class 10 | 11 | -------------------------------------------------------------------------------- /src/java/MyConst.java: -------------------------------------------------------------------------------- 1 | class MyConst{ 2 | final static String jlInteger = "java/lang/Integer"; 3 | final static String jlStringBuilder = "java/lang/StringBuilder"; 4 | final static String jlDouble = "java/lang/Double"; 5 | final static String jlFloat = "java/lang/Float"; 6 | } 7 | -------------------------------------------------------------------------------- /src/java/asm-all-5.2.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dynaroars/dig/7e1ebec4899d7687607e4fdd4c284dd835d68eec/src/java/asm-all-5.2.jar -------------------------------------------------------------------------------- /src/kip.py: -------------------------------------------------------------------------------- 1 | import prover.tests.nla 2 | prover.tests.nla.verify_all() 3 | -------------------------------------------------------------------------------- /src/prover/tests/kip_test_common_del.py: -------------------------------------------------------------------------------- 1 | import time 2 | from vu_common import pause, is_empty, vset 3 | from z3util import model_str, get_vars 4 | from z3 import And, Implies, unknown, Solver, unsat, Not 5 | import logging 6 | import kip 7 | Prog = kip.Prog 8 | 9 | kip.logger.setLevel(logging.INFO) 10 | 11 | 12 | if __name__ == "__main__": 13 | import doctest 14 | doctest.testmod() 15 | 16 | -------------------------------------------------------------------------------- /src/tmp.py: -------------------------------------------------------------------------------- 1 | 2 | import z3 3 | 4 | from helpers.miscs import Miscs 5 | from data.symstates import SymStates 6 | 7 | x = z3.Int('x') 8 | y = z3.Int('y') 9 | f = z3.Or(z3.And(x <= -2 , y==0), x== y -1) 10 | 11 | terms = Miscs.get_terms_fixed_coefs([x,y], 2, 1) 12 | 13 | print('input formula', f) 14 | print('convex hull: ') 15 | for t in terms: 16 | v,stat = SymStates.mmaximize(f, t, iupper=20) 17 | if v is not None: 18 | assert isinstance(v, int), v 19 | c = t <= v 20 | print(c) 21 | 22 | 23 | -------------------------------------------------------------------------------- /src/todo.txt: -------------------------------------------------------------------------------- 1 | infer prepost : make sure to turn off ieq filtering, otherwise it will removes term involving only inputs (which we actually want) 2 | --------------------------------------------------------------------------------