├── .classpath ├── .gitignore ├── .hgignore ├── .hgtags ├── .project ├── .pydevproject ├── .settings ├── org.eclipse.core.resources.prefs ├── org.eclipse.core.runtime.prefs ├── org.eclipse.jdt.ui.prefs ├── org.eclipse.m2e.core.prefs ├── org.maven.ide.eclipse.prefs └── run_config │ ├── AllSTPTests.launch │ ├── AllYices2Tests.launch │ ├── AllYicesTests.launch │ ├── STP SketchShowcaseSuite.launch │ ├── binary-jar-test.launch │ ├── globals.launch │ ├── local-test-Armando-curr-file.launch │ ├── local-test-miniTest210MinLoop.launch │ ├── local-test-miniTest213ArrExpScaling.launch │ ├── minitest b230.launch │ └── platform-binary-jar-test.launch ├── AUTHORS ├── COPYING ├── ChangeLog ├── LICENSE ├── LIGHT_README ├── Makefile ├── NEWS ├── README ├── benchmarks ├── allreduce │ ├── allreduce0.sk │ ├── allreduce0_intrange.sk │ ├── allreduce1.sk │ ├── allreduce2.sk │ ├── allreduce3.sk │ ├── allreduce4.sk │ └── allreduce5.sk ├── bughunting │ └── tr2d_1.sk ├── cav15 │ ├── astOpt.sk │ ├── astOpt.synthesized │ ├── lang.sk │ ├── lang.synthesized │ ├── langState.sk │ ├── langState.synthesized │ ├── lcB.sk │ ├── lcB.synthesized │ ├── lcB_e.sk │ ├── lcB_e.synthesized │ ├── lcP.sk │ ├── lcP.synthesized │ ├── lcP_e.sk │ ├── lcP_e.synthesized │ ├── runEx.sk │ ├── runEx.synthesized │ ├── tcEx.sk │ ├── tcEx.synthesized │ ├── tcUni.sk │ ├── tcUni.synthesized │ ├── treeEx.sk │ ├── treeEx.synthesized │ ├── treeGen.sk │ └── treeGen.synthesized ├── cg │ ├── bug_expr.sk │ ├── bug_expr2.sk │ ├── cg1.sk │ ├── cg2.sk │ ├── cg_readme.txt │ ├── vectrans.sk │ └── vectrans_expr.sk ├── invTest.sk ├── neo1.sk ├── neo2.sk ├── neo3.sk ├── neo4.sk ├── neo5.sk ├── neo6.sk ├── neo7.sk ├── neohookean.cc ├── neohookean.h ├── neohookean2.cc ├── popl │ ├── benchmark1.sk │ ├── benchmark2.sk │ ├── benchmark3.sk │ ├── benchmark4.sk │ ├── benchmark5.sk │ ├── benchmark6.sk │ ├── benchmark7.sk │ ├── example1.sk │ ├── example1_imm.sk │ ├── example1_min.sk │ ├── example1_min_imm.sk │ ├── example2.sk │ ├── example2_imm.sk │ ├── example3.sk │ ├── example3_imm.sk │ ├── example4.sk │ ├── example4_imm.sk │ ├── example_arity.sk │ ├── outputToDB.py │ └── perftest.sh ├── sk_neohookean.sk ├── sk_neohookean2.sk ├── testAssume.sk ├── tests │ ├── arr_assume │ │ ├── cg0.sk │ │ ├── cg1.sk │ │ ├── cg2.sk │ │ ├── cg3.sk │ │ ├── cg4.sk │ │ ├── cg4_noassume_b.sk │ │ ├── cg4_noassume_correct.sk │ │ ├── cg4_noassume_wrong.sk │ │ ├── cg5.sk │ │ ├── cg5_noassume.sk │ │ ├── sparsify.sk │ │ ├── sparsify_noassume.sk │ │ ├── spmv.sk │ │ └── spmv_noassume.sk │ ├── bfs1.sk │ ├── bfs2.sk │ ├── bfs3.sk │ ├── partition3.sk │ ├── partition3_expr.sk │ ├── partition4.sk │ ├── partition4_expr.sk │ ├── testAlltoall.sk │ ├── topo1.sk │ ├── topo2.sk │ ├── topo3.sk │ ├── topo4.sk │ ├── topo5.sk │ └── topo6.sk └── transpose │ ├── bug_tr17_expr │ └── tr17_expr.sk │ ├── fortran │ ├── ft.f │ ├── global.h │ ├── mpinpb.h │ ├── testchar.f │ └── timers.f │ ├── run │ ├── compile │ ├── get_timers.py │ ├── testdouble.cpp │ ├── tr17.cpp │ ├── tr17.h │ └── transpose.cpp │ ├── test_expr.sk │ ├── tmp1.sk │ ├── tr1.sk │ ├── tr10.sk │ ├── tr11.sk │ ├── tr12.sk │ ├── tr13.sk │ ├── tr14.sk │ ├── tr15.sk │ ├── tr16.sk │ ├── tr17.sk │ ├── tr17_expr.sk │ ├── tr17_nohole.sk │ ├── tr1_manualfix.sk │ ├── tr2.sk │ ├── tr2_manualfix.sk │ ├── tr3.sk │ ├── tr3_manualfix.sk │ ├── tr4.sk │ ├── tr4_manualfix.sk │ ├── tr5.sk │ ├── tr6.sk │ ├── tr7.sk │ ├── tr8.sk │ └── tr9.sk ├── customcodegen └── SCP.java ├── distconfig └── linux_rpm │ ├── debian.changelog.jinja2 │ ├── debian.control.jinja2 │ ├── debian.rules.jinja2 │ ├── jinja2_macros.txt │ ├── release_number │ ├── sketch-frontend.dsc.jinja2 │ └── sketch-frontend.spec.jinja2 ├── docs └── SketchManual │ ├── Makefile │ ├── advancedUsage.tex │ ├── baseLanguage.tex │ ├── compilerUsage.tex │ ├── credits.tex │ ├── distribution.tex │ ├── holes.tex │ ├── macros.tex │ ├── manual.pdf │ ├── manual.tex │ └── stdlib.tex ├── mpidiff ├── mpimerge ├── pldi ├── rex1a │ ├── rex1a.main.cpp │ ├── rex1a.sk │ └── rex1a.spec.cpp ├── rex1b │ ├── rex1b.main.cpp │ ├── rex1b.sk │ └── rex1b.spec.cpp ├── rex1c │ ├── rex1c.main.cpp │ ├── rex1c.sk │ └── rex1c.spec.cpp ├── rex1d │ ├── rex1d.main.cpp │ ├── rex1d.sk │ └── rex1d.spec.cpp └── tests │ ├── testClosure.sk │ ├── testClosureScope.sk │ ├── testDeadCodeElimination.sk │ └── testFloat.sk ├── pom.xml ├── reports └── currently-failing-unit-tests ├── scripts ├── bench │ └── test_output.txt ├── build │ ├── assembly │ │ ├── jar_assembly.xml │ │ ├── launchers_assembly.xml │ │ ├── noarch_launchers_assembly.xml │ │ ├── platform_jar_assembly.xml │ │ └── tar_src_assembly.xml │ └── cegis-script-hacked │ │ └── cegis ├── code_standards │ ├── bash_functions.sh │ ├── code_standards.py │ └── path_resolv.py ├── debug │ └── sketch ├── dist_win32 │ ├── INSTALL │ └── sketch ├── expand.awk ├── includes │ └── jinja2_macros.txt ├── noinstall │ └── sketch ├── pragmarenamer.py ├── rewrite_fcns.py ├── run_jinja2.py ├── stats.awk ├── unix │ ├── final │ │ ├── psketch │ │ ├── sketch │ │ └── stensk │ ├── install │ ├── psketch.jinja2 │ ├── sketch.jinja2 │ └── stensk.jinja2 ├── vim │ ├── ftdetect │ │ └── sketch.vim │ ├── install.sh │ ├── sk2html.zsh │ └── syntax │ │ └── sketch.vim └── windows │ ├── final │ ├── installer │ │ ├── EnvVarUpdate.nsh │ │ ├── Plugins │ │ │ ├── GetVersion.dll │ │ │ ├── README │ │ │ ├── UAC.dll │ │ │ └── textreplace.dll │ │ ├── TextReplace.nsh │ │ ├── UAC.nsh │ │ ├── getjre.nsh │ │ ├── sketch │ │ ├── sketch-installer.nsi │ │ └── sketch.bat │ ├── psketch │ ├── sketch │ └── stensk │ ├── psketch.jinja2 │ ├── sketch.jinja2 │ └── stensk.jinja2 ├── spmd ├── bug_backend_infloop.input ├── doc │ └── mpisketch.pptx ├── miniTest_backend1.sk ├── miniTest_backend2.sk ├── miniTest_bug_backend_infloop.sk ├── miniTest_bug_backend_infloop2.sk ├── miniTest_codegen1.sk ├── miniTest_codegen2.sk ├── miniTest_for1.sk ├── miniTest_for2.sk ├── miniTest_for3.sk ├── miniTest_for4.sk ├── miniTest_for5.sk ├── miniTest_frontend1.sk ├── miniTest_frontend2.sk ├── miniTest_frontend3.sk ├── miniTest_frontend4.sk ├── miniTest_frontend4_sten.sk ├── miniTest_frontend4_stenvoid.sk ├── miniTest_infiniteLoop.sk ├── miniTest_spmd1.sk ├── miniTest_stencil1.sk ├── miniTest_stencil2.sk ├── miniTest_stencil3.sk ├── miniTest_while1.sk ├── miniTest_while2.sk ├── rbgs.sk ├── rbgs_1.sk ├── rbgs_2.sk ├── rbgst.sk ├── rbgst1.sk ├── sten1d.sk ├── sten1d_K.sk ├── sten1d_spmd.sk ├── testBarrier.sk ├── testCall.sk ├── testFork.sk ├── testIf.sk ├── testLocal.sk ├── testOutParam.sk ├── testPid.sk ├── testTransfer.sk ├── testWhile.sk ├── test_struct0.sk ├── test_struct1.sk ├── test_struct2.sk ├── test_struct3.sk ├── test_struct4.sk └── tmp_test.sk └── src ├── experiments ├── Jack │ └── test.skh ├── Kliment │ ├── constraints.data │ ├── out │ ├── sketch.cpp │ ├── sketch.h │ └── sketch.sk ├── Pankaj │ ├── basic_sparse.sk │ ├── constraints01.txt │ ├── nativeIntsBug.sk │ ├── processArithBug.sk │ └── testWithFile01.sk ├── PointCars │ ├── Car.skh │ ├── Geometry.skh │ ├── ParallelPark.sk │ ├── ParallelParkBest.sk │ └── World.skh ├── Quadcopter │ ├── CopterModel.skh │ ├── script.sh │ ├── simpleCopterTest.sk │ ├── updownController.sk │ └── vis.sh └── sk │ ├── models │ ├── README │ ├── expo_model.skh │ ├── expo_model_old_cegis.skh │ ├── gcd_model.skh │ ├── gcd_model_old_cegis.skh │ ├── generators.skh │ ├── ilog_model.skh │ ├── ilog_model_old_cegis.skh │ ├── lcm_model.skh │ ├── lcm_model_old_cegis.skh │ ├── matpmult_model.skh │ ├── matpmult_model_old_cegis.skh │ ├── model_usage │ │ ├── activitysched_sortindex │ │ │ ├── model.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_bubblesort.sk │ │ │ └── options.skh │ │ ├── binarysearch_sort │ │ │ ├── model.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_bubblesort.sk │ │ │ └── options.skh │ │ ├── closest_power_two_ilog │ │ │ ├── forig.sk │ │ │ ├── full.sk │ │ │ ├── generators.skh │ │ │ ├── log_real.sk │ │ │ ├── model.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_power_two.sk │ │ │ ├── nomodel_power_two_1.sk │ │ │ └── options.skh │ │ ├── closestpair_sortfull │ │ │ ├── model.sk │ │ │ ├── model_debug.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_bubblesort.sk │ │ │ └── options.skh │ │ ├── gcd_n_numbers │ │ │ ├── forig.sk │ │ │ ├── full.sk │ │ │ ├── model.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_euclidean.sk │ │ │ └── options.skh │ │ ├── lcm_add_rationals │ │ │ ├── model.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_lcm_euclidean.sk │ │ │ ├── nomodel_lcm_linear.sk │ │ │ └── options.skh │ │ ├── lcm_n_numbers │ │ │ ├── full.sk │ │ │ ├── model.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_lcm_euclidean.sk │ │ │ ├── nomodel_lcm_linear.sk │ │ │ └── options.skh │ │ ├── matexpo_matmult │ │ │ ├── model.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_stdmatmult.sk │ │ │ └── options.skh │ │ ├── multiproc-arraysmooth_partition │ │ │ ├── model.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_goodpartition.sk │ │ │ └── options.skh │ │ ├── polyderiv_mult │ │ │ ├── full.sk │ │ │ ├── model.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_standardmult.sk │ │ │ └── options.skh │ │ ├── polyeval_mult_expo │ │ │ ├── model.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_standardmult_stdexp.sk │ │ │ └── options.skh │ │ ├── powerroot_sqrt │ │ │ ├── model.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── nomodel_binarysearch.sk │ │ │ └── options.skh │ │ └── primality_sqrt │ │ │ ├── model.sk │ │ │ ├── model_basic.sk │ │ │ ├── model_old_cegis.sk │ │ │ ├── model_old_cegis_basic.sk │ │ │ ├── nomodel_binarysearch.sk │ │ │ └── options.skh │ ├── model_verification │ │ ├── binarysearch_models_sqrt │ │ │ └── check.sk │ │ ├── bubblesort_models_sort │ │ │ └── check.sk │ │ ├── bubblesort_models_sortfull │ │ │ └── check.sk │ │ ├── bubblesort_models_sortindex │ │ │ └── check.sk │ │ ├── euclidean_models_gcd │ │ │ └── check.sk │ │ ├── goodpartition_models_partition │ │ │ └── check.sk │ │ ├── karatsuba_models_mult │ │ │ └── mult_karatsuba.sk │ │ ├── linear_models_lcm │ │ │ └── check.sk │ │ ├── power_two_models_ilog │ │ │ └── check.sk │ │ ├── primality_sqrt │ │ │ └── check.sk │ │ ├── standardmult_models_mult │ │ │ └── check.sk │ │ ├── standardmult_stdexp_models_expo │ │ │ └── check.sk │ │ └── stdmatmult_models_matpmult │ │ │ └── check.sk │ ├── moresketchified_model_usage │ │ ├── activitysched_sortindex │ │ │ ├── model.sk │ │ │ ├── nomodel_bubblesort.sk │ │ │ └── options.skh │ │ ├── binarysearch_sort │ │ │ ├── model.sk │ │ │ ├── nomodel_bubblesort.sk │ │ │ └── options.skh │ │ ├── closest_power_two_ilog │ │ │ ├── generators.skh │ │ │ ├── log_real.sk │ │ │ ├── model.sk │ │ │ ├── nomodel_power_two_1.sk │ │ │ └── options.skh │ │ ├── closestpair_sortfull │ │ │ ├── model.sk │ │ │ ├── nomodel_bubblesort.sk │ │ │ └── options.skh │ │ ├── gcd_n_numbers │ │ │ ├── model.sk │ │ │ ├── nomodel_euclidean.sk │ │ │ └── options.skh │ │ ├── lcm_n_numbers │ │ │ ├── model.sk │ │ │ ├── nomodel_lcm_linear.sk │ │ │ └── options.skh │ │ ├── matexpo_matmult │ │ │ ├── model.sk │ │ │ ├── nomodel_stdmatmult.sk │ │ │ └── options.skh │ │ ├── multiproc-arraysmooth_partition │ │ │ ├── model.sk │ │ │ ├── nomodel_goodpartition.sk │ │ │ └── options.skh │ │ ├── polyderiv_mult │ │ │ ├── model.sk │ │ │ ├── nomodel_standardmult.sk │ │ │ └── options.skh │ │ ├── polyeval_mult_expo │ │ │ ├── model.sk │ │ │ ├── nomodel_standardmult_stdexp.sk │ │ │ └── options.skh │ │ ├── powerroot_sqrt │ │ │ ├── model.sk │ │ │ ├── nomodel_binarysearch.sk │ │ │ └── options.skh │ │ └── primality_sqrt │ │ │ ├── model.sk │ │ │ ├── nomodel_binarysearch.sk │ │ │ └── options.skh │ ├── mult_model.skh │ ├── mult_model_old_cegis.skh │ ├── partition_model.skh │ ├── partition_model_old_cegis.skh │ ├── scripts │ │ ├── analyzelog.sh │ │ ├── analyzelogs.sh │ │ ├── angelic.sh │ │ ├── cegis.sh │ │ ├── cegis_new.sh │ │ ├── command_master_analysis │ │ ├── commands_pretty │ │ ├── compile_data.sh │ │ ├── old_cegis.sh │ │ ├── run_benchmark.sh │ │ ├── run_benchmark_test.sh │ │ ├── run_model_nomodel.sh │ │ ├── run_models_nomodels.sh │ │ ├── runall.sh │ │ ├── runmodel.sh │ │ └── stats.awk │ ├── sort_model.skh │ ├── sort_model_old_cegis.skh │ ├── sortfull_model.skh │ ├── sortfull_model_old_cegis.skh │ ├── sortindex_model.skh │ ├── sortindex_model_old_cegis.skh │ ├── sqrt_model.skh │ └── sqrt_model_old_cegis.skh │ ├── par │ ├── barrier │ │ ├── b1_3_2.sk │ │ ├── b1_3_3.sk │ │ ├── b1_4_2.sk │ │ ├── b1_4_3.sk │ │ ├── b1_5_2.sk │ │ ├── b2_2_3.sk │ │ ├── b2_2_3_simp.sk │ │ ├── b2_3_2.sk │ │ ├── b2_3_2_simp.sk │ │ └── b2_3_3.sk │ ├── bigSketches │ │ ├── barrierBuggy.sk │ │ ├── barrierSketch0.sk │ │ ├── barrierSketch1.sk │ │ ├── barrierSketch2.sk │ │ ├── barrierSketch3.sk │ │ ├── barrierSol.sk │ │ ├── coarseLocking.sk │ │ ├── debug.sk │ │ ├── fineLocking.sk │ │ ├── fineLockingSK2.sk │ │ ├── fineLockingSk1.sk │ │ ├── fineLockingSketch.sk │ │ ├── llset.skh │ │ └── seqTest1.sk │ ├── billsList │ │ ├── list.skh │ │ ├── listMove.sk │ │ └── listPush.sk │ ├── dining_philosophers │ │ ├── sketch.skh │ │ ├── sketch_2_1.sk │ │ ├── sketch_3_1.sk │ │ ├── sketch_3_2.sk │ │ ├── sketch_3_3.sk │ │ ├── sketch_3_4.sk │ │ ├── sketch_3_5.sk │ │ ├── sketch_4_1.sk │ │ ├── sketch_4_2.sk │ │ ├── sketch_4_3.sk │ │ ├── sketch_5_1.sk │ │ ├── sketch_5_2.sk │ │ ├── sketch_5_3.sk │ │ ├── soln.skh │ │ ├── soln_2_1.sk │ │ ├── soln_3_1.sk │ │ ├── soln_3_2.sk │ │ ├── soln_3_3.sk │ │ ├── soln_3_4.sk │ │ ├── soln_3_5.sk │ │ ├── soln_4_1.sk │ │ ├── soln_4_2.sk │ │ ├── soln_4_3.sk │ │ ├── soln_5_1.sk │ │ ├── soln_5_2.sk │ │ └── soln_5_3.sk │ ├── errorTest │ │ └── miniTest1.sk │ ├── fine-locking_list-based_set │ │ ├── addRemove.skh │ │ ├── driver_a_pr.skh │ │ ├── driver_pa_r.skh │ │ ├── driver_papr.skh │ │ ├── driver_par.skh │ │ ├── old │ │ │ ├── fineLocking.sk │ │ │ ├── fineLockingSK2.sk │ │ │ ├── fineLockingSk1.sk │ │ │ └── llset.skh │ │ ├── old2 │ │ │ ├── driver_a_pr.skh │ │ │ ├── driver_pa_r.skh │ │ │ ├── sketch1_2_a-a-r-r.sk │ │ │ ├── sketch1_2_a-a_rr.sk │ │ │ ├── sketch1_2_aa_r-r.sk │ │ │ ├── sketch1_2_aaaa_r-r-r-r.sk │ │ │ ├── sketch2_2_a-a-r-r.sk │ │ │ ├── sketch2_2_a-a_rr.sk │ │ │ ├── sketch2_2_aa_r-r.sk │ │ │ ├── sketch2_2_aaaa_r-r-r-r.sk │ │ │ ├── soln_2_a-a_rr.sk │ │ │ ├── soln_2_aa_r-r.sk │ │ │ └── soln_a-a-r-r.sk │ │ ├── set.skh │ │ ├── sketch1Find.skh │ │ ├── sketch1_2_a-a-a-a-r-r-r-r.sk │ │ ├── sketch1_2_a-a-r-r.sk │ │ ├── sketch1_2_a-a_rr.sk │ │ ├── sketch1_2_a-r-a-r-a-r-a-r.sk │ │ ├── sketch1_2_a-r-a-r.sk │ │ ├── sketch1_2_a-r.sk │ │ ├── sketch1_2_aa_r-r.sk │ │ ├── sketch1_3_a-r-a-r-a-r.sk │ │ ├── sketch1_4_a-r-a-r.sk │ │ ├── sketch2Find.skh │ │ ├── sketch2_2_a-a-a-a-r-r-r-r.sk │ │ ├── sketch2_2_a-a-r-r.sk │ │ ├── sketch2_2_a-a_rr.sk │ │ ├── sketch2_2_a-r-a-r-a-r-a-r.sk │ │ ├── sketch2_2_a-r-a-r.sk │ │ ├── sketch2_2_a-r.sk │ │ ├── sketch2_2_aa_r-r.sk │ │ ├── sketch2_3_a-r-a-r-a-r.sk │ │ ├── sketch2_4_a-r-a-r.sk │ │ ├── solnFind.skh │ │ ├── soln_2_a-a-a-a-r-r-r-r.sk │ │ ├── soln_2_a-a-r-r.sk │ │ ├── soln_2_a-r-a-r-a-r-a-r.sk │ │ ├── soln_2_a-r-a-r.sk │ │ ├── soln_2_a-r.sk │ │ ├── soln_3_a-r-a-r-a-r.sk │ │ ├── soln_4_a-a-r-r-a-a-r-r.sk │ │ ├── soln_4_a-r-a-r-a-r-a-r.sk │ │ ├── soln_4_a-r-a-r.sk │ │ ├── testsolnFind.skh │ │ └── testsoln_4_a-r-a-r-a-r-a-r.sk │ ├── harrisList │ │ ├── add.sk │ │ ├── list.skh │ │ └── remove.sk │ ├── lazy_list-based_set │ │ ├── driver_a_pr.skh │ │ ├── driver_pa_r.skh │ │ ├── driver_papr.skh │ │ ├── driver_par.skh │ │ ├── lzsketch1_2_a-a-a-r-r-r.sk │ │ ├── lzsketch1_2_a-a-r-r.sk │ │ ├── lzsketch1_2_a-r-a-r.sk │ │ ├── lzsoln_2_a-a-r-r.sk │ │ ├── lzsoln_2_a-r-a-r.sk │ │ ├── set.skh │ │ ├── sketch1LockRemove.skh │ │ ├── sketch1_2_aa_r-r.sk │ │ ├── solnAdd.skh │ │ ├── solnRemove.skh │ │ └── soln_2_a-a_rr.sk │ ├── lock-free_queue │ │ ├── driver_e_pd.skh │ │ ├── driver_pe_d.skh │ │ ├── driver_ped.skh │ │ ├── driver_pepd.skh │ │ ├── old │ │ │ ├── dequeueSketch.sk │ │ │ ├── dequeueSolution.sk │ │ │ ├── dequeueSolution2.sk │ │ │ ├── enqueueDequeueSimulSketch.sk │ │ │ ├── enqueueDequeueSketch.sk │ │ │ ├── enqueueDequeueSketch2.sk │ │ │ ├── enqueueDequeueSketch2.sk.cpp │ │ │ ├── enqueueDequeueSketch3.sk │ │ │ ├── enqueueSketch.sk │ │ │ └── enqueueSolution.sk │ │ ├── old2 │ │ │ ├── driver_e_pd.skh │ │ │ ├── driver_pe_d.skh │ │ │ ├── sketchD1E1_2_e-d-e-d-e-d-e-d.sk │ │ │ ├── sketchD1E1_2_e-e-e-d-d-d.sk │ │ │ ├── sketchD1E1_2_e-e-e-e-d-d-d-d.sk │ │ │ ├── sketchD1E1_2_e-e-e-e_dddd.sk │ │ │ ├── sketchD1E1_2_e-e_dd.sk │ │ │ ├── sketchD1E1_2_ee_d-d.sk │ │ │ ├── sketchD1E1_2_eeee_d-d-d-d.sk │ │ │ ├── sketchD1E1_3_e-d-e-d-e-d.sk │ │ │ ├── sketchD1E2_2_e-d-e-d-e-d-e-d.sk │ │ │ ├── sketchD1E2_2_e-e-e-d-d-d.sk │ │ │ ├── sketchD1E2_2_e-e-e-e-d-d-d-d.sk │ │ │ ├── sketchD1E2_2_e-e-e-e_dddd.sk │ │ │ ├── sketchD1E2_2_e-e_dd.sk │ │ │ ├── sketchD1E2_2_ee_d-d.sk │ │ │ ├── sketchD1E2_2_eeee_d-d-d-d.sk │ │ │ ├── sketchD1E2_3_e-d-e-d-e-d.sk │ │ │ ├── sketchD1E2_3_e-e-e_ddd.sk │ │ │ ├── sketchD1E2_3_eee_d-d-d.sk │ │ │ ├── sketchD1_2_e-e-e-d-d-d.sk │ │ │ ├── sketchD1_2_ee_d-d.sk │ │ │ ├── sketchD1_3_eee_d-d-d.sk │ │ │ ├── sketchE1_2_e-e_dd.sk │ │ │ ├── sketchE1_3_e-e-e_ddd.sk │ │ │ ├── sketchE2_2_e-e_dd.sk │ │ │ ├── sketchE2_3_e-e-e_ddd.sk │ │ │ ├── soln_2_e-e-e-e-e-e-e-e_dddddddd.sk │ │ │ ├── soln_2_e-e-e-e-e-e_d-d-d-d-d-d.sk │ │ │ ├── soln_2_e-e-e-e-e-e_dddddd.sk │ │ │ ├── soln_2_e-e-e-e_dddd.sk │ │ │ ├── soln_2_e-e_dd.sk │ │ │ ├── soln_2_ee_d-d.sk │ │ │ ├── soln_2_eeee_d-d-d-d.sk │ │ │ ├── soln_2_eeeeee_d-d-d-d-d-d.sk │ │ │ ├── soln_2_eeeeeeee_d-d-d-d-d-d-d-d.sk │ │ │ ├── soln_3_e-e-e_ddd.sk │ │ │ ├── soln_3_eee_d-d-d.sk │ │ │ ├── soln_4_e-e-e-e_dddd.sk │ │ │ └── soln_4_eeee_d-d-d-d.sk │ │ ├── queue.skh │ │ ├── sketch1Dequeue.skh │ │ ├── sketch1Enqueue.skh │ │ ├── sketch2Dequeue.skh │ │ ├── sketch2Enqueue.skh │ │ ├── sketchD1E1_2_e-d-e-d.sk │ │ ├── sketchD1E1_2_e-d.sk │ │ ├── sketchD1E1_2_e-e-d-d.sk │ │ ├── sketchD1E2_2_e-d-e-d.sk │ │ ├── sketchD1E2_2_e-d.sk │ │ ├── sketchD1E2_2_e-e-d-d.sk │ │ ├── sketchD1_2_e-d-e-d.sk │ │ ├── sketchD1_2_e-d.sk │ │ ├── sketchD1_2_e-e-d-d.sk │ │ ├── sketchD1_2_eeee_d-d-d-d.sk │ │ ├── sketchD1_3_eee_d-d-d.sk │ │ ├── sketchD1_eeee_d-d-d-d.sk │ │ ├── sketchD2E2_2_e-d.sk │ │ ├── sketchE1_2_e-d-e-d.sk │ │ ├── sketchE1_2_e-d.sk │ │ ├── sketchE1_2_e-e-d-d.sk │ │ ├── sketchE1_2_e-e-e-e_dddd.sk │ │ ├── sketchE1_3_e-e-e_ddd.sk │ │ ├── sketchE2_2_e-d-e-d.sk │ │ ├── sketchE2_2_e-d.sk │ │ ├── sketchE2_2_e-e-d-d.sk │ │ ├── sketchE2_2_e-e-e-e_dddd.sk │ │ ├── sketchE2_3_e-e-e_ddd.sk │ │ ├── soln2_2_e-d-e-d.sk │ │ ├── solnDequeue.skh │ │ ├── solnEnqueue.skh │ │ ├── soln_2_e-d-e-d.sk │ │ ├── soln_2_e-d.sk │ │ ├── soln_2_e-e-d-d.sk │ │ ├── soln_2_e-e-e-e_dddd.sk │ │ ├── soln_2_eeee_d-d-d-d.sk │ │ ├── soln_3_e-d-e-d-e-d.sk │ │ ├── soln_3_e-e-e-d-d-d.sk │ │ ├── soln_3_e-e-e_ddd.sk │ │ ├── soln_3_eee_d-d-d.sk │ │ └── soln_4_e-d-e-d.sk │ ├── perftest.py │ ├── pldi08 │ │ ├── barrier.py │ │ ├── benchmarks │ │ │ ├── barrier │ │ │ │ ├── b1_3_2.sk │ │ │ │ ├── b1_3_3.sk │ │ │ │ ├── b1_4_2.sk │ │ │ │ ├── b1_4_3.sk │ │ │ │ ├── b1_5_2.sk │ │ │ │ ├── b2_2_3.sk │ │ │ │ ├── b2_2_3_simp.sk │ │ │ │ ├── b2_3_2.sk │ │ │ │ ├── b2_3_2_simp.sk │ │ │ │ └── b2_3_3.sk │ │ │ ├── dining_philosophers │ │ │ │ ├── sketch.skh │ │ │ │ └── soln.skh │ │ │ ├── fine-locking_list-based_set │ │ │ │ ├── addRemove.skh │ │ │ │ ├── driver_a_pr.skh │ │ │ │ ├── driver_pa_r.skh │ │ │ │ ├── driver_papr.skh │ │ │ │ ├── driver_par.skh │ │ │ │ ├── old │ │ │ │ │ └── llset.skh │ │ │ │ ├── old2 │ │ │ │ │ ├── driver_a_pr.skh │ │ │ │ │ └── driver_pa_r.skh │ │ │ │ ├── set.skh │ │ │ │ ├── sketch1Find.skh │ │ │ │ ├── sketch2Find.skh │ │ │ │ ├── solnFind.skh │ │ │ │ └── testsolnFind.skh │ │ │ ├── lazy_list-based_set │ │ │ │ ├── driver_a_pr.skh │ │ │ │ ├── driver_pa_r.skh │ │ │ │ ├── driver_papr.skh │ │ │ │ ├── driver_par.skh │ │ │ │ ├── set.skh │ │ │ │ ├── sketch1LockRemove.skh │ │ │ │ ├── solnAdd.skh │ │ │ │ └── solnRemove.skh │ │ │ └── lock-free_queue │ │ │ │ ├── driver_e_pd.skh │ │ │ │ ├── driver_pe_d.skh │ │ │ │ ├── driver_ped.skh │ │ │ │ ├── driver_pepd.skh │ │ │ │ ├── old │ │ │ │ └── enqueueDequeueSketch2.sk.cpp │ │ │ │ ├── old2 │ │ │ │ ├── driver_e_pd.skh │ │ │ │ └── driver_pe_d.skh │ │ │ │ ├── queue.skh │ │ │ │ ├── sketch1Dequeue.skh │ │ │ │ ├── sketch1Enqueue.skh │ │ │ │ ├── sketch2Dequeue.skh │ │ │ │ ├── sketch2Enqueue.skh │ │ │ │ ├── solnDequeue.skh │ │ │ │ └── solnEnqueue.skh │ │ ├── examples │ │ │ └── queue.skh │ │ ├── finelist1.py │ │ ├── finelist2.py │ │ ├── finelist3.py │ │ ├── finelist4.py │ │ ├── lazylist.py │ │ ├── perftest.py │ │ ├── philo.py │ │ ├── plditable.py │ │ ├── queue.sk │ │ ├── queue1.py │ │ ├── queue1_2.py │ │ ├── queue2.py │ │ ├── regtest.py │ │ ├── runalltests.sh │ │ ├── runtabletests.sh │ │ ├── runtest.sh │ │ └── sketch.py │ ├── pldi08perfdata │ │ ├── b1_3_2.sk.err │ │ ├── b1_3_2.sk.out │ │ ├── b1_3_3.sk.err │ │ ├── b1_3_3.sk.out │ │ ├── b1_4_2.sk.err │ │ ├── b1_4_2.sk.out │ │ ├── b1_4_3.sk.err │ │ ├── b1_4_3.sk.out │ │ ├── b2_3_2.sk.err │ │ ├── b2_3_2.sk.out │ │ ├── barrier.perf │ │ ├── barrier.py │ │ ├── barrier.py.perf │ │ ├── barrier2pml.pml │ │ ├── data.csv │ │ ├── finelist1.perf │ │ ├── finelist1.py │ │ ├── finelist1.py.perf │ │ ├── finelist2.perf │ │ ├── finelist2.py │ │ ├── finelist3.perf │ │ ├── finelist3.py │ │ ├── finelist4.perf │ │ ├── finelist4.py │ │ ├── lazylist.perf │ │ ├── lazylist.py │ │ ├── lzsketch1_2_a-a-r-r.sk.err │ │ ├── lzsketch1_2_a-a-r-r.sk.out │ │ ├── lzsketch1_2_a-r-a-r.sk.err │ │ ├── lzsketch1_2_a-r-a-r.sk.out │ │ ├── lzsoln_2_a-a-r-r.sk.err │ │ ├── lzsoln_2_a-a-r-r.sk.out │ │ ├── lzsoln_2_a-r-a-r.sk.err │ │ ├── lzsoln_2_a-r-a-r.sk.out │ │ ├── perfdata-08-03.csv │ │ ├── philo.perf │ │ ├── philo.py │ │ ├── psketch_graph_data.xls │ │ ├── psketch_perf_08.03.27.0057 │ │ ├── queue1.perf │ │ ├── queue1.py │ │ ├── queue1_2.py │ │ ├── queue2.perf │ │ ├── queue2.py │ │ ├── runtest.sh │ │ ├── sketch1_2_a-a-a-a-r-r-r-r.sk.err │ │ ├── sketch1_2_a-a-a-a-r-r-r-r.sk.out │ │ ├── sketch1_2_a-a-r-r.sk.err │ │ ├── sketch1_2_a-a-r-r.sk.out │ │ ├── sketch1_2_a-r-a-r-a-r-a-r.sk.err │ │ ├── sketch1_2_a-r-a-r-a-r-a-r.sk.out │ │ ├── sketch1_2_a-r-a-r.sk.err │ │ ├── sketch1_2_a-r-a-r.sk.out │ │ ├── sketch1_2_a-r.sk.err │ │ ├── sketch1_2_a-r.sk.out │ │ ├── sketch1_3_a-r-a-r-a-r.sk.err │ │ ├── sketch1_3_a-r-a-r-a-r.sk.out │ │ ├── sketch1_4_a-r-a-r.sk.err │ │ ├── sketch1_4_a-r-a-r.sk.out │ │ ├── sketch2_2_a-a-a-a-r-r-r-r.sk.err │ │ ├── sketch2_2_a-a-a-a-r-r-r-r.sk.out │ │ ├── sketch2_2_a-a-r-r.sk.err │ │ ├── sketch2_2_a-a-r-r.sk.out │ │ ├── sketch2_2_a-r-a-r-a-r-a-r.sk.err │ │ ├── sketch2_2_a-r-a-r-a-r-a-r.sk.out │ │ ├── sketch2_2_a-r-a-r.sk.err │ │ ├── sketch2_2_a-r-a-r.sk.out │ │ ├── sketch2_2_a-r.sk.err │ │ ├── sketch2_2_a-r.sk.out │ │ ├── sketch2_3_a-r-a-r-a-r.sk.err │ │ ├── sketch2_3_a-r-a-r-a-r.sk.out │ │ ├── sketch2_4_a-r-a-r.sk.err │ │ ├── sketch2_4_a-r-a-r.sk.out │ │ ├── sketchD1E1_2_e-d-e-d.sk.err │ │ ├── sketchD1E1_2_e-d-e-d.sk.out │ │ ├── sketchD1E1_2_e-d.sk.err │ │ ├── sketchD1E1_2_e-d.sk.out │ │ ├── sketchD1E1_2_e-e-d-d.sk.err │ │ ├── sketchD1E1_2_e-e-d-d.sk.out │ │ ├── sketchD1E2_2_e-d-e-d.sk.err │ │ ├── sketchD1E2_2_e-d-e-d.sk.out │ │ ├── sketchD1E2_2_e-d.sk.err │ │ ├── sketchD1E2_2_e-d.sk.out │ │ ├── sketchD1_2_e-d-e-d.sk.err │ │ ├── sketchD1_2_e-d-e-d.sk.out │ │ ├── sketchD1_2_e-d.sk.err │ │ ├── sketchD1_2_e-d.sk.out │ │ ├── sketchD1_2_e-e-d-d.sk.err │ │ ├── sketchD1_2_e-e-d-d.sk.out │ │ ├── sketchD1_2_eeee_d-d-d-d.sk.err │ │ ├── sketchD1_2_eeee_d-d-d-d.sk.out │ │ ├── sketchD1_3_eee_d-d-d.sk.err │ │ ├── sketchD1_3_eee_d-d-d.sk.out │ │ ├── sketchE1_2_e-d-e-d.sk.err │ │ ├── sketchE1_2_e-d-e-d.sk.out │ │ ├── sketchE1_2_e-d.sk.err │ │ ├── sketchE1_2_e-d.sk.out │ │ ├── sketchE1_2_e-e-d-d.sk.err │ │ ├── sketchE1_2_e-e-d-d.sk.out │ │ ├── sketchE1_2_e-e-e-e_dddd.sk.err │ │ ├── sketchE1_2_e-e-e-e_dddd.sk.out │ │ ├── sketchE1_3_e-e-e_ddd.sk.err │ │ ├── sketchE1_3_e-e-e_ddd.sk.out │ │ ├── sketchE2_2_e-d-e-d.sk.err │ │ ├── sketchE2_2_e-d-e-d.sk.out │ │ ├── sketchE2_2_e-d.sk.err │ │ ├── sketchE2_2_e-d.sk.out │ │ ├── sketchE2_2_e-e-d-d.sk.err │ │ ├── sketchE2_2_e-e-d-d.sk.out │ │ ├── sketchE2_2_e-e-e-e_dddd.sk.err │ │ ├── sketchE2_2_e-e-e-e_dddd.sk.out │ │ ├── sketchE2_3_e-e-e_ddd.sk.err │ │ ├── sketchE2_3_e-e-e_ddd.sk.out │ │ ├── sketch_3_1.sk.err │ │ ├── sketch_3_1.sk.out │ │ ├── sketch_3_2.sk.err │ │ ├── sketch_3_2.sk.out │ │ ├── sketch_3_5.sk.err │ │ ├── sketch_3_5.sk.out │ │ ├── sketch_4_1.sk.err │ │ ├── sketch_4_1.sk.out │ │ ├── sketch_4_2.sk.err │ │ ├── sketch_4_2.sk.out │ │ ├── sketch_4_3.sk.err │ │ ├── sketch_4_3.sk.out │ │ ├── sketch_5_1.sk.err │ │ ├── sketch_5_1.sk.out │ │ ├── sketch_5_2.sk.err │ │ ├── sketch_5_2.sk.out │ │ ├── sketch_5_3.sk.err │ │ ├── sketch_5_3.sk.out │ │ ├── soln_2_a-a-a-a-r-r-r-r.sk.err │ │ ├── soln_2_a-a-a-a-r-r-r-r.sk.out │ │ ├── soln_2_a-a-r-r.sk.err │ │ ├── soln_2_a-a-r-r.sk.out │ │ ├── soln_2_a-r-a-r-a-r-a-r.sk.err │ │ ├── soln_2_a-r-a-r-a-r-a-r.sk.out │ │ ├── soln_2_a-r-a-r.sk.err │ │ ├── soln_2_a-r-a-r.sk.out │ │ ├── soln_2_a-r.sk.err │ │ ├── soln_2_a-r.sk.out │ │ ├── soln_2_e-d-e-d.sk.err │ │ ├── soln_2_e-d-e-d.sk.out │ │ ├── soln_2_e-d.sk.err │ │ ├── soln_2_e-d.sk.out │ │ ├── soln_2_e-e-d-d.sk.err │ │ ├── soln_2_e-e-d-d.sk.out │ │ ├── soln_2_e-e-e-e_dddd.sk.err │ │ ├── soln_2_e-e-e-e_dddd.sk.out │ │ ├── soln_2_eeee_d-d-d-d.sk.err │ │ ├── soln_2_eeee_d-d-d-d.sk.out │ │ ├── soln_3_1.sk.err │ │ ├── soln_3_1.sk.out │ │ ├── soln_3_2.sk.err │ │ ├── soln_3_2.sk.out │ │ ├── soln_3_5.sk.err │ │ ├── soln_3_5.sk.out │ │ ├── soln_3_a-r-a-r-a-r.sk.err │ │ ├── soln_3_a-r-a-r-a-r.sk.out │ │ ├── soln_3_e-d-e-d-e-d.sk.err │ │ ├── soln_3_e-d-e-d-e-d.sk.out │ │ ├── soln_3_e-e-e-d-d-d.sk.err │ │ ├── soln_3_e-e-e-d-d-d.sk.out │ │ ├── soln_3_e-e-e_ddd.sk.err │ │ ├── soln_3_e-e-e_ddd.sk.out │ │ ├── soln_3_eee_d-d-d.sk.err │ │ ├── soln_3_eee_d-d-d.sk.out │ │ ├── soln_4_1.sk.err │ │ ├── soln_4_1.sk.out │ │ ├── soln_4_2.sk.err │ │ ├── soln_4_2.sk.out │ │ ├── soln_4_3.sk.err │ │ ├── soln_4_3.sk.out │ │ ├── soln_4_a-a-r-r-a-a-r-r.sk.err │ │ ├── soln_4_a-a-r-r-a-a-r-r.sk.out │ │ ├── soln_4_a-r-a-r-a-r-a-r.sk.err │ │ ├── soln_4_a-r-a-r-a-r-a-r.sk.out │ │ ├── soln_4_a-r-a-r.sk.err │ │ ├── soln_4_a-r-a-r.sk.out │ │ ├── soln_4_e-d-e-d.sk.err │ │ ├── soln_4_e-d-e-d.sk.out │ │ ├── soln_5_1.sk.err │ │ ├── soln_5_1.sk.out │ │ ├── soln_5_2.sk.err │ │ ├── soln_5_2.sk.out │ │ ├── soln_5_3.sk.err │ │ ├── soln_5_3.sk.out │ │ └── ~lazylist.perf │ ├── primitives.skh │ ├── sketch.py │ └── thesis │ │ ├── barrier │ │ ├── barrier.skh │ │ ├── barrier2_N3_T2.sk │ │ ├── barrier2_N3_T3.sk │ │ ├── barrier2_N4_T3.sk │ │ ├── barrier_N3_T2.sk │ │ ├── barrier_N3_T3.sk │ │ └── barrier_N4_T3.sk │ │ ├── billsList │ │ ├── dining_philosophers │ │ ├── philosopher.skh │ │ ├── philosopher_N3_T5.sk │ │ ├── philosopher_N4_T3.sk │ │ └── philosopher_N5_T3.sk │ │ ├── fine-locking_list-based_set │ │ ├── addRemove.skh │ │ ├── addRemove2.skh │ │ ├── driver_a_pr.skh │ │ ├── driver_pa_r.skh │ │ ├── driver_papr.skh │ │ ├── driver_par.skh │ │ ├── set.skh │ │ ├── sketch1Find.skh │ │ ├── sketch1_2_a-a-a-a-r-r-r-r.sk │ │ ├── sketch1_2_a-a_rr.sk │ │ ├── sketch1_2_a-r-a-r-a-r-a-r.sk │ │ ├── sketch1_2_a-r-a-r.sk │ │ ├── sketch1_2_aa_r-r.sk │ │ ├── sketch1_3_a-r-a-r-a-r.sk │ │ ├── sketch1_4_a-r-a-r.sk │ │ ├── sketch2Find.skh │ │ ├── sketch2_2_a-a-a-a-r-r-r-r.bu │ │ ├── sketch2_2_a-a_rrNw.sk │ │ ├── sketch2_2_a-r-a-r-a-r-a-r.sk │ │ ├── sketch2_2_a-r-a-r.sk │ │ ├── sketch2_2_a-rNw.sk │ │ ├── sketch2_3_a-r-a-r-a-r.sk │ │ └── sketch2_4_a-r-a-r.bu │ │ ├── harrisList │ │ ├── addSk1.skh │ │ ├── addSk2.skh │ │ ├── addSol.skh │ │ ├── driver_par.skh │ │ ├── list.skh │ │ ├── removeSk1.skh │ │ ├── removeSol.skh │ │ └── removeWish.skh │ │ ├── lazy_list-based_set │ │ ├── driver_a_pr.skh │ │ ├── driver_pa_r.skh │ │ ├── driver_papr.skh │ │ ├── driver_par.skh │ │ ├── lzsketch1_2_a-a-a-r-r-r.sk │ │ ├── lzsketch1_2_a-a-r-r.sk │ │ ├── lzsketch1_2_a-r-a-r.sk │ │ ├── set.skh │ │ ├── sketch1LockRemove.skh │ │ ├── sketch1_2_aa_r-r.sk │ │ ├── solnAdd.skh │ │ └── solnRemove.skh │ │ ├── lock-free_queue │ │ ├── driver_e_pd.skh │ │ ├── driver_pe_d.skh │ │ ├── driver_ped.skh │ │ ├── driver_pepd.skh │ │ ├── queue.skh │ │ ├── sketch1Dequeue.skh │ │ ├── sketch1Enqueue.skh │ │ ├── sketch2Dequeue.skh │ │ ├── sketch2Enqueue.skh │ │ ├── sketchD1E1_2_e-d-e-d.sk │ │ ├── sketchD1E1_2_e-d.sk │ │ ├── sketchD1E1_2_e-e-d-d.sk │ │ ├── sketchD1E2_2_e-d-e-d.sk │ │ ├── sketchD1E2_2_e-e-d-d.sk │ │ ├── sketchD1_2_e-d-e-d.sk │ │ ├── sketchD1_2_e-e-d-d.sk │ │ ├── sketchD1_2_eeee_d-d-d-d.sk │ │ ├── sketchD1_3_eee_d-d-d.sk │ │ ├── sketchD2E2_2_e-d.sk │ │ ├── sketchE1_2_e-d-e-d.sk │ │ ├── sketchE1_2_e-e-d-d.sk │ │ ├── sketchE1_3_e-e-e_ddd.sk │ │ ├── sketchE2_2_e-d-e-d.sk │ │ ├── sketchE2_2_e-d.sk │ │ ├── sketchE2_2_e-e-d-d.sk │ │ ├── sketchE2_2_e-e-e-e_dddd.sk │ │ ├── sketchE2_3_e-e-e_ddd.sk │ │ ├── solnDequeue.skh │ │ └── solnEnqueue.skh │ │ ├── primitives.skh │ │ └── runBenchmarks.sh │ ├── seq │ ├── AES │ │ ├── aesFragment1.sk │ │ ├── aesFragment2.sk │ │ ├── aesFragmentIdeal.sk │ │ ├── aesFullStage.sk │ │ ├── aesFullStageBest.sk │ │ ├── aesFullStageClean.sk │ │ ├── aesFullStageSmart.sk │ │ ├── aesFullStageSomeHelp.sk │ │ ├── buggy.sk │ │ ├── fullAES.sk │ │ ├── fullAESsketch.sk │ │ ├── normalRound.sk │ │ ├── normalRoundSimplified.sk │ │ ├── normalRoundSimplified2.sk │ │ ├── nromalRoundOpt.sk │ │ └── simplelRound.sk │ ├── BitTest.java │ ├── CRC │ │ ├── crc2.sk │ │ ├── crc3.sk │ │ ├── crc4.sk │ │ ├── crc5.sk │ │ └── crcBasic.sk │ ├── GFMul.sk │ ├── GFMul_table.sk │ ├── Karatsuba.sk │ ├── KaratsubaFewUnknowns.sk │ ├── KaratsubaInt.sk │ ├── KaratsubaPoly.sk │ ├── KaratsubaRec.sk │ ├── ParserTest.java │ ├── assert1.sk │ ├── assert2.sk │ ├── assert3.sk │ ├── assert4.sk │ ├── bench2 │ │ ├── conf │ │ │ ├── analyzelog.cpp │ │ │ ├── make.sh │ │ │ ├── makejobs.cpp │ │ │ ├── pitimer.cpp │ │ │ ├── pitimer.h │ │ │ ├── postproc.sh │ │ │ ├── runajob.sh │ │ │ ├── runjob.cpp │ │ │ ├── start.cpp │ │ │ ├── tabulate.cpp │ │ │ └── tests.cfg │ │ └── perf │ │ │ ├── aesperf.c │ │ │ ├── aestables.h │ │ │ ├── normalRound.c │ │ │ ├── normalRound.h │ │ │ ├── normalRoundTweaked.c │ │ │ ├── normalRound_test.c │ │ │ ├── pitimer.cpp │ │ │ └── pitimer.h │ ├── benchmarks │ │ ├── KaratsubaPoly.sk │ │ ├── KaratsubaPolyAlt.sk │ │ ├── aesFullStage.sk │ │ ├── aesFullStageBest.sk │ │ ├── aesFullStageClean.sk │ │ ├── altLog2.sk │ │ ├── collectSideInfo.sh │ │ ├── conf │ │ │ ├── makescript.cpp │ │ │ └── tests.cfg │ │ ├── dequeue.sk │ │ ├── dequeueSequential.sk │ │ ├── dequeueSketch.sk │ │ ├── dequeue_preprocessed.sk │ │ ├── des.sk │ │ ├── enqueueSeq.sk │ │ ├── enqueueSeqSK.sk │ │ ├── log2.sk │ │ ├── logcount.sk │ │ ├── parallel1.sk │ │ ├── parallel2.0.sk │ │ ├── parallel2.sk │ │ ├── parallelSketch.sk │ │ ├── parity.sk │ │ ├── polynomial.sk │ │ ├── postproc.sh │ │ ├── reverse.sk │ │ ├── runAES.sh │ │ ├── setAdd.sk │ │ ├── tblcrc.sk │ │ └── test.sh │ ├── bitSwapNoVector.sk │ ├── bitSwapSomeVector.sk │ ├── bitSwapVector.sk │ ├── bittest1.sk │ ├── bittest2.sk │ ├── buggy │ │ ├── Karatsuba1.ske │ │ ├── buggyCounting.sk │ │ ├── buggyGFMul.sk │ │ ├── buggyPoly.sk │ │ ├── buggylog2.sk │ │ ├── buggylog2_2.sk │ │ ├── buggylog2_3.sk │ │ ├── buggyparity2.sk │ │ ├── dropThirdNoRange.sk │ │ ├── dropThirdNoRange_oneLineBug.sk │ │ ├── infiniteRecursionNotReallyABug.sk │ │ ├── manySolutionsButNotReallyBuggy.sk │ │ ├── multiplyBug.ske │ │ ├── polynomial.sk │ │ ├── polynomial2.sk │ │ ├── redBlackTree.sk │ │ ├── reverseSketch.sk │ │ ├── simpleCounting1.sk │ │ ├── simpleCountingBug1.sk │ │ └── simpleCountingBug2.sk │ ├── count.sk │ ├── crc.sk │ ├── crc2.sk │ ├── crc_cast.sk │ ├── dct-2.sk │ ├── debug-lt.sk │ ├── debug.sk │ ├── des.sk │ ├── dropThirdNoRange.sk │ ├── dropThirdNoRange16.sk │ ├── dropthird.sk │ ├── errorHandling │ │ ├── miniTest1.sk │ │ ├── miniTest2.sk │ │ ├── miniTest3.sk │ │ └── miniTest4.sk │ ├── firstZero.sk │ ├── flop │ │ ├── addtest1.sk │ │ ├── addtest2.sk │ │ ├── addtest3.sk │ │ ├── floatAdd.skh │ │ ├── floatCommon.skh │ │ ├── floatDiv.sk │ │ ├── floatMul.skh │ │ ├── isqrt.sk │ │ └── sqrt.sk │ ├── gilad │ │ ├── TestLeq.sk │ │ ├── bad.sk │ │ ├── bad2.sk │ │ ├── bad3.sk │ │ ├── bad4.sk │ │ ├── count2.sk │ │ ├── count3.sk │ │ ├── count4-better.sk │ │ ├── count4.sk │ │ ├── count5.sk │ │ ├── count6-magic.cpp │ │ ├── count6-magic.h │ │ ├── count6-magic.sk │ │ ├── filter.sk │ │ ├── sk-test │ │ ├── skcpp │ │ ├── sktest │ │ └── testconst.sk │ ├── hardSort.sk │ ├── inline1.sk │ ├── inline2.sk │ ├── languageTranslator │ │ ├── bm.sk │ │ ├── lambda1.sk │ │ ├── lambda2.sk │ │ ├── lambda21.sk │ │ ├── lambda22.sk │ │ ├── lambda2_1.sk │ │ ├── lang2.sk │ │ ├── lang_new.sk │ │ ├── language.sk │ │ ├── language_compact.sk │ │ ├── toyLang2.sk │ │ ├── toyLang21.sk │ │ ├── toyLang22.sk │ │ ├── toyLang2_1.sk │ │ └── toyLang_1.sk │ ├── log2.sk │ ├── logCountingSketch.sk │ ├── loopAssertedTest.sk │ ├── loopTest.sk │ ├── matrixTranspose.sk │ ├── matrixTranspose2.sk │ ├── miniTest13.sk │ ├── miniTest15.sk │ ├── miniTest18.sk │ ├── miniTest2.sk │ ├── miniTest5.sk │ ├── miniTestb665.sk │ ├── mult32Bit.sk │ ├── parity.sk │ ├── perftest │ │ ├── Karatsuba.sk │ │ ├── bigProblems │ │ │ ├── KaratsubaPoly.sk │ │ │ ├── aesFullStageBest.sk │ │ │ ├── des2.sk │ │ │ └── logcount.sk │ │ ├── hardGenerator.sk │ │ ├── help.sh │ │ ├── logcount.sk │ │ ├── perftest.sh │ │ └── polynomialInt.sk │ ├── polynomial.sk │ ├── promela │ │ ├── basic.sk │ │ ├── dequeueSolution2.sk │ │ └── enqueue.sk │ ├── ras │ │ ├── AP_Union │ │ │ ├── fibinacci.sk │ │ │ ├── struct_array_test.sk │ │ │ └── union01.sk │ │ ├── PSKETCH │ │ │ └── Demo-Set │ │ │ │ ├── harness.skh │ │ │ │ ├── set.sk │ │ │ │ └── set.skh │ │ ├── Refinement │ │ │ ├── 01-strength-reduction.sk │ │ │ ├── 02-strength-reduction.sk │ │ │ ├── 03-strength-reduction.sk │ │ │ ├── bug01.sk │ │ │ ├── scan01.sk │ │ │ ├── strength-reduction.sk │ │ │ ├── test01.sk │ │ │ ├── test02.sk │ │ │ ├── test03-binary-tree.sk │ │ │ └── test04-binary-tree-faster.sk │ │ ├── SKETCH │ │ │ ├── 01.smullyan-stamps.sk │ │ │ ├── 02.dijkstra-dutch-flag-problem-1.sk │ │ │ ├── 02.dijkstra-tests.h │ │ │ ├── Sparse │ │ │ │ ├── DenseMV.java │ │ │ │ ├── SpMV-COO-sketch02.sk │ │ │ │ ├── SpMV-CSR-sketch01.sk │ │ │ │ ├── SpMV-DIA-sketch01.sk │ │ │ │ ├── model.skh │ │ │ │ ├── sparse-MV-1.sk │ │ │ │ ├── sparse-MV-2.sk │ │ │ │ ├── sparse-sparsify-desparsify.sk │ │ │ │ └── ufun-test1.sk │ │ │ ├── TreeSet │ │ │ │ ├── HashSetComplete.skh │ │ │ │ ├── SetTest.sk │ │ │ │ └── TreeSet.skh │ │ │ ├── adverse.sk │ │ │ ├── loops.sk │ │ │ ├── non-linear.sk │ │ │ ├── predicates1.sk │ │ │ ├── send-money-2.sk │ │ │ ├── send-money.sk │ │ │ ├── sparse-MV-from-repre-fun.sk │ │ │ ├── sparse-sparsify-desparsify.sk │ │ │ ├── strassen.sk │ │ │ ├── struct-test.sk │ │ │ ├── struct-test.smt │ │ │ ├── test-constant-replacer-on-globals.sk │ │ │ ├── test-regr-global.sk │ │ │ ├── test-regr-local.sk │ │ │ ├── test01.sk │ │ │ ├── test10.sk │ │ │ └── test_structs_with_arrays.sk │ │ └── Wallace │ │ │ ├── wallace-andreas-dadda-3.sk │ │ │ ├── wallace-andreas.sk │ │ │ ├── wallace-andreas2.sk │ │ │ ├── wallace-for-lexin-3.sk │ │ │ ├── wallace-for-lexin-4.sk │ │ │ ├── wallace-test.sk │ │ │ └── wallace2-orig.sk │ ├── regens │ │ ├── 001.sk │ │ ├── 002.sk │ │ ├── 003.sk │ │ ├── 004.sk │ │ ├── 005.sk │ │ ├── 006.sk │ │ ├── 007.sk │ │ ├── 008.sk │ │ ├── 009.sk │ │ ├── 010.sk │ │ ├── 011.sk │ │ └── err │ │ │ ├── 001.sk │ │ │ ├── 002.sk │ │ │ ├── 003.sk │ │ │ ├── 004.sk │ │ │ ├── 005.sk │ │ │ ├── 006.sk │ │ │ ├── 007.sk │ │ │ ├── 008.sk │ │ │ └── 009.sk │ ├── reverse.sk │ ├── reverse2.sk │ ├── sagar │ │ └── graph-classifier │ │ │ ├── cll.sk │ │ │ ├── dll.sk │ │ │ ├── result.tex │ │ │ ├── sc.sk │ │ │ ├── sll.sk │ │ │ ├── test_sll.cpp │ │ │ ├── tree.sk │ │ │ ├── treepp.sk │ │ │ └── treerp.sk │ ├── simpleCounting.sk │ ├── simpleCountingSketch.sk │ ├── sort.sk │ ├── sorting │ │ ├── hardSort.sk │ │ ├── hardSortBUGGY.sk │ │ ├── hardSortCommonBug.sk │ │ ├── hardSortParam.sk │ │ ├── hardSortReduced.sk │ │ ├── hardSortVerif.sk │ │ └── hardSortVerif2.sk │ ├── stencil │ │ ├── cmpTest1.sk │ │ └── mt5trans.sk │ ├── structs │ │ ├── atomic.sk │ │ └── basic.sk │ ├── supersten1.sk │ ├── supersten2.sk │ ├── tableBasedAddition.sk │ ├── tableDES.opt │ ├── test │ ├── test-debug │ ├── test4vpoly.sk │ ├── thesisBenchmarks │ │ ├── .cpp │ │ ├── HashSetComplete.skh │ │ ├── Makefile │ │ ├── Pollard.sk │ │ ├── SetTest.sk │ │ ├── TreeSet.skh │ │ ├── afa_spec │ │ ├── appdx.awk │ │ ├── appdx.raw │ │ ├── armando │ │ │ ├── batcher │ │ │ │ ├── Makefile │ │ │ │ ├── batcher_sort.sk │ │ │ │ ├── batcher_sort_test.py │ │ │ │ ├── extract_from_sketch.py │ │ │ │ ├── visual_4.html │ │ │ │ ├── visual_5.html │ │ │ │ └── visual_6.html │ │ │ ├── llreverse.cpp │ │ │ ├── llreverse.exe │ │ │ ├── llreverse.h │ │ │ ├── llreverse.sk │ │ │ ├── llreverse_test.cpp │ │ │ ├── morton │ │ │ │ ├── after_lower_ir.txt │ │ │ │ ├── after_partial_evaluation.txt │ │ │ │ ├── assert_not_neg_one.diff │ │ │ │ ├── before_unvectorizing.txt │ │ │ │ ├── jburnim_morton.sk │ │ │ │ ├── jburnim_morton_easier.sk │ │ │ │ ├── jburnim_morton_easiest.sk │ │ │ │ ├── jburnim_morton_easiest_fixed.cpp │ │ │ │ ├── jburnim_morton_easiest_fixed.h │ │ │ │ ├── jburnim_morton_easiest_fixed.sk │ │ │ │ └── reduced.sk │ │ │ ├── script │ │ │ ├── test_test.cpp │ │ │ └── transpose │ │ │ │ ├── Makefile │ │ │ │ ├── actual_xpose.sk │ │ │ │ ├── bitvec.h │ │ │ │ ├── dis.txt │ │ │ │ ├── fixedarr.h │ │ │ │ ├── print_matrix.c │ │ │ │ ├── result.xpose │ │ │ │ ├── sse_transpose.cc │ │ │ │ ├── transpose.sk │ │ │ │ ├── transpose_paper.sk │ │ │ │ ├── xpose.cpp │ │ │ │ ├── xpose.h │ │ │ │ ├── xpose.sk │ │ │ │ ├── xpose2.sk │ │ │ │ └── xpose_out.txt │ │ ├── ccc_test │ │ ├── clean.sh │ │ ├── compress.sk │ │ ├── compress2.sk │ │ ├── debug.sk │ │ ├── debug2.sk │ │ ├── doublyLinkedList.dmcs.gz │ │ ├── doublyLinkedList.sk │ │ ├── effectsOfOptims.sh │ │ ├── enqueueSeqSK.sk │ │ ├── hardSort.sk │ │ ├── harder │ │ │ ├── jburnim_morton.sk │ │ │ ├── karatsuba_c2_i2.sk │ │ │ ├── karatsuba_c3_i2.sk │ │ │ ├── xpose.sk │ │ │ └── xposeBit.sk │ │ ├── inPlaceTranspose.sk │ │ ├── isolateRightmost.sk │ │ ├── jburnim_morton_easier.sk │ │ ├── jburnim_morton_easiest.sk │ │ ├── listReverseEasy.sk │ │ ├── listReverseHarder.sk │ │ ├── log2.sk │ │ ├── log2VarLoop.sk │ │ ├── logcount.sk │ │ ├── logcount2.sk │ │ ├── lss.sk │ │ ├── lssBig.sk │ │ ├── lss_hardest.dmcs.gz │ │ ├── out │ │ ├── parity.dmcs.gz │ │ ├── parity.sk │ │ ├── polynomial.dmcs.gz │ │ ├── polynomial.sk │ │ ├── polynomial_inv.dmcs.gz │ │ ├── registerlesSwap.sk │ │ ├── regtest.sh │ │ ├── regtest2.sh │ │ ├── result3 │ │ ├── reverse.sk │ │ ├── runBenchmarks.sh │ │ ├── runkar.sh │ │ ├── sizeExpers │ │ │ ├── HashSetComplete.skh │ │ │ ├── SetTest.skh │ │ │ ├── TreeSet.skh │ │ │ ├── enqueue.skh │ │ │ ├── enqueue_N3.sk │ │ │ ├── enqueue_N4.sk │ │ │ ├── enqueue_N5.sk │ │ │ ├── enqueue_N6.sk │ │ │ ├── listReverse.skh │ │ │ ├── reverse_N3.sk │ │ │ ├── reverse_N4.sk │ │ │ ├── reverse_N5.sk │ │ │ ├── reverse_N6.sk │ │ │ ├── runBenchmarks.sh │ │ │ ├── setTest_T4.sk │ │ │ ├── setTest_T5.sk │ │ │ └── setTest_T6.sk │ │ ├── tableBasedAddition.sk │ │ ├── timetable.dat │ │ ├── tmp.dmcs.gz │ │ ├── tmp.sh │ │ ├── troubleBenchs.sh │ │ ├── tutorial1.sk │ │ ├── tutorial2.sk │ │ ├── tutorial3.sk │ │ └── uglier │ │ │ ├── batcher_sort.sk │ │ │ ├── debug.sk │ │ │ ├── rabinKarpMatcher.sk │ │ │ ├── send-money.sk │ │ │ ├── sparse-MV-2.sk │ │ │ ├── spmv.sk │ │ │ └── stackFreeDFS.sk │ └── tutorial │ │ └── listReSource.sk │ └── sten │ ├── benchmarks │ ├── cacheObv1d.sk │ ├── cacheObv1d2.sk │ ├── cacheObv1d3.sk │ ├── cacheObv1d4.sk │ ├── cacheObv1dGood.sk │ ├── cacheObv1dGood2.sk │ ├── cacheObv1dGood3.sk │ ├── cacheObv2d1.sk │ ├── cacheObvDebug.sk │ ├── finitefp2d.sk │ ├── fourpt2d.sk │ ├── fourpt2d2.sk │ ├── mgInterp.sk │ ├── mgInterp2.sk │ ├── mgInterpEasy.f │ ├── mgInterpEasy.sk │ ├── mgInterpEasy2.f │ ├── mgInterpEasy2.sk │ ├── perftest.sh │ ├── rb2d.sk │ ├── rb2dEasy.sk │ ├── rb2dEasypp.f │ ├── rb2dEasypp.sk │ ├── rb2dHard.sk │ ├── rb2dSimple.sk │ ├── rb2dSimpleOdd.sk │ ├── rb2dSimplepp.sk │ ├── rb2dpp.sk │ ├── rb3d.sk │ ├── rb3dFast.sk │ ├── rb3dFastpp.sk │ ├── rb3dHard.sk │ ├── rb3dHardpp.sk │ ├── rb3dSimple.sk │ ├── rb3dSimpleComplete.sk │ ├── rb3dSimpleCompletepp.sk │ ├── rb3dSimpleOdd.sk │ ├── rb3dSimpleOddpp.sk │ ├── rb3dSimplepp.sk │ ├── rb3dpp.sk │ ├── times.out │ └── upwind.sk │ ├── buggy │ ├── buggy1.sk │ ├── buggy2.sk │ ├── buggy3.sk │ └── buggy4.sk │ ├── convert.sh │ ├── debug.sk │ ├── miniTest11.sk │ ├── miniTest14.sk │ ├── miniTest2.sk │ └── mpipoisson.sk ├── main ├── java │ ├── ec │ │ └── util │ │ │ ├── MersenneTwisterFast.java │ │ │ └── ThreadLocalMT.java │ └── sketch │ │ ├── compiler │ │ ├── Directive.java │ │ ├── ast │ │ │ ├── core │ │ │ │ ├── Annotation.java │ │ │ │ ├── DummyFENode.java │ │ │ │ ├── FEContext.java │ │ │ │ ├── FEIdentityVisitor.java │ │ │ │ ├── FENode.java │ │ │ │ ├── FENullVisitor.java │ │ │ │ ├── FEReplacer.java │ │ │ │ ├── FETypedVisitor.java │ │ │ │ ├── FEVisitor.java │ │ │ │ ├── FEVisitorException.java │ │ │ │ ├── FieldDecl.java │ │ │ │ ├── Function.java │ │ │ │ ├── NameResolver.java │ │ │ │ ├── Package.java │ │ │ │ ├── Parameter.java │ │ │ │ ├── Program.java │ │ │ │ ├── SymbolTable.java │ │ │ │ ├── TempVarGen.java │ │ │ │ ├── exprs │ │ │ │ │ ├── ExprADTHole.java │ │ │ │ │ ├── ExprArrayInit.java │ │ │ │ │ ├── ExprArrayRange.java │ │ │ │ │ ├── ExprBinary.java │ │ │ │ │ ├── ExprConstChar.java │ │ │ │ │ ├── ExprConstFloat.java │ │ │ │ │ ├── ExprConstInt.java │ │ │ │ │ ├── ExprConstant.java │ │ │ │ │ ├── ExprField.java │ │ │ │ │ ├── ExprFieldsListMacro.java │ │ │ │ │ ├── ExprFunCall.java │ │ │ │ │ ├── ExprLambda.java │ │ │ │ │ ├── ExprLiteral.java │ │ │ │ │ ├── ExprLocalVariables.java │ │ │ │ │ ├── ExprNamedParam.java │ │ │ │ │ ├── ExprNew.java │ │ │ │ │ ├── ExprNullPtr.java │ │ │ │ │ ├── ExprSpecialStar.java │ │ │ │ │ ├── ExprStar.java │ │ │ │ │ ├── ExprTernary.java │ │ │ │ │ ├── ExprTuple.java │ │ │ │ │ ├── ExprTupleAccess.java │ │ │ │ │ ├── ExprType.java │ │ │ │ │ ├── ExprTypeCast.java │ │ │ │ │ ├── ExprUnary.java │ │ │ │ │ ├── ExprVar.java │ │ │ │ │ ├── Expression.java │ │ │ │ │ └── regens │ │ │ │ │ │ ├── ExprAlt.java │ │ │ │ │ │ ├── ExprChoiceBinary.java │ │ │ │ │ │ ├── ExprChoiceSelect.java │ │ │ │ │ │ ├── ExprChoiceUnary.java │ │ │ │ │ │ ├── ExprParen.java │ │ │ │ │ │ └── ExprRegen.java │ │ │ │ ├── stmts │ │ │ │ │ ├── Statement.java │ │ │ │ │ ├── StmtAssert.java │ │ │ │ │ ├── StmtAssign.java │ │ │ │ │ ├── StmtAssume.java │ │ │ │ │ ├── StmtAtomicBlock.java │ │ │ │ │ ├── StmtBlock.java │ │ │ │ │ ├── StmtBreak.java │ │ │ │ │ ├── StmtContinue.java │ │ │ │ │ ├── StmtDoWhile.java │ │ │ │ │ ├── StmtEmpty.java │ │ │ │ │ ├── StmtExpr.java │ │ │ │ │ ├── StmtFor.java │ │ │ │ │ ├── StmtFunDecl.java │ │ │ │ │ ├── StmtIfThen.java │ │ │ │ │ ├── StmtImplicitVarDecl.java │ │ │ │ │ ├── StmtInsertBlock.java │ │ │ │ │ ├── StmtLoop.java │ │ │ │ │ ├── StmtMinLoop.java │ │ │ │ │ ├── StmtMinimize.java │ │ │ │ │ ├── StmtReorderBlock.java │ │ │ │ │ ├── StmtReturn.java │ │ │ │ │ ├── StmtSpAssert.java │ │ │ │ │ ├── StmtSwitch.java │ │ │ │ │ ├── StmtVarDecl.java │ │ │ │ │ └── StmtWhile.java │ │ │ │ └── typs │ │ │ │ │ ├── NamedTupleType.java │ │ │ │ │ ├── NotYetComputedType.java │ │ │ │ │ ├── StructDef.java │ │ │ │ │ ├── Type.java │ │ │ │ │ ├── TypeArray.java │ │ │ │ │ ├── TypeComparisonResult.java │ │ │ │ │ ├── TypeFunction.java │ │ │ │ │ ├── TypePrimitive.java │ │ │ │ │ ├── TypeStructRef.java │ │ │ │ │ ├── TypeType.java │ │ │ │ │ └── TypeUnknownStructRef.java │ │ │ ├── cuda │ │ │ │ ├── exprs │ │ │ │ │ ├── CudaBlockDim.java │ │ │ │ │ ├── CudaInstrumentCall.java │ │ │ │ │ ├── CudaThreadIdx.java │ │ │ │ │ └── ExprRange.java │ │ │ │ ├── stmts │ │ │ │ │ ├── CudaSyncthreads.java │ │ │ │ │ └── StmtParfor.java │ │ │ │ └── typs │ │ │ │ │ └── CudaMemoryType.java │ │ │ ├── promela │ │ │ │ └── stmts │ │ │ │ │ ├── StmtFork.java │ │ │ │ │ └── StmtJoin.java │ │ │ ├── scala │ │ │ │ └── exprs │ │ │ │ │ └── ExprConstUnit.java │ │ │ └── spmd │ │ │ │ ├── exprs │ │ │ │ ├── SpmdNProc.java │ │ │ │ └── SpmdPid.java │ │ │ │ └── stmts │ │ │ │ ├── SpmdBarrier.java │ │ │ │ └── StmtSpmdfork.java │ │ ├── cmdline │ │ │ ├── BoundOptions.java │ │ │ ├── CudaOptions.java │ │ │ ├── DebugOptions.java │ │ │ ├── FrontendOptions.java │ │ │ ├── ParallelOptions.java │ │ │ ├── SMTBoundOptions.java │ │ │ ├── SMTOptions.java │ │ │ ├── SemanticsOptions.java │ │ │ ├── SolverOptions.java │ │ │ └── SpmdOptions.java │ │ ├── codegenerators │ │ │ ├── GenerateDocs.java │ │ │ ├── NodesToC.java │ │ │ ├── NodesToCOld.java │ │ │ ├── NodesToCPrintTest.java │ │ │ ├── NodesToCTest.java │ │ │ ├── NodesToCUDA.java │ │ │ ├── NodesToH.java │ │ │ ├── NodesToSuperCTest.java │ │ │ ├── NodesToSuperCpp.java │ │ │ ├── NodesToSuperH.java │ │ │ ├── OutputHoleFunc.java │ │ │ ├── SNodesToC.java │ │ │ ├── SNodesToFortran.java │ │ │ └── tojava │ │ │ │ ├── ExprJavaConstructor.java │ │ │ │ ├── NodesToJava.java │ │ │ │ └── StmtIODecl.java │ │ ├── controlflow │ │ │ ├── AnyTypeLattice.java │ │ │ ├── CFG.java │ │ │ ├── CFGBuilder.java │ │ │ ├── CFGNode.java │ │ │ ├── CountLattice.java │ │ │ ├── DataFlow.java │ │ │ ├── Lattice.java │ │ │ ├── StatementCounter.java │ │ │ ├── StrictTypeLattice.java │ │ │ └── package.html │ │ ├── dataflow │ │ │ ├── CloneHoles.java │ │ │ ├── DataflowWithFixpoint.java │ │ │ ├── MapStack.java │ │ │ ├── MethodState.java │ │ │ ├── PartialEvaluator.java │ │ │ ├── SelectFunctionsToAnalyze.java │ │ │ ├── abstractValue.java │ │ │ ├── abstractValueType.java │ │ │ ├── cflowChecks │ │ │ │ ├── CfcState.java │ │ │ │ ├── CfcValue.java │ │ │ │ ├── Cfctype.java │ │ │ │ └── PerformFlowChecks.java │ │ │ ├── deadCodeElimination │ │ │ │ ├── BackwardDataflow.java │ │ │ │ ├── EliminateDeadCode.java │ │ │ │ ├── LVSet.java │ │ │ │ ├── LiveVariableAV.java │ │ │ │ ├── LiveVariableVType.java │ │ │ │ ├── LiveVariableVarState.java │ │ │ │ ├── MinimizeLocalVariables.java │ │ │ │ └── joinAV.java │ │ │ ├── eliminateTransAssign │ │ │ │ ├── EliminateTransAssns.java │ │ │ │ ├── TAsupperBottom.java │ │ │ │ ├── TAvalueType.java │ │ │ │ ├── TAvarState.java │ │ │ │ ├── taUpdater.java │ │ │ │ └── transAssignAbsValue.java │ │ │ ├── nodesToSB │ │ │ │ ├── IntAbsValue.java │ │ │ │ ├── IntState.java │ │ │ │ ├── IntVtype.java │ │ │ │ ├── NtsbState.java │ │ │ │ ├── NtsbValue.java │ │ │ │ ├── NtsbVtype.java │ │ │ │ └── ProduceBooleanFunctions.java │ │ │ ├── preprocessor │ │ │ │ ├── PreprocessSketch.java │ │ │ │ ├── PropagateFinals.java │ │ │ │ ├── SimplifyVarNames.java │ │ │ │ └── TypeInferenceForStars.java │ │ │ ├── recursionCtrl │ │ │ │ ├── AdvancedRControl.java │ │ │ │ ├── BaseRControl.java │ │ │ │ ├── DelayedInlineRControl.java │ │ │ │ ├── RecursionControl.java │ │ │ │ └── ZeroInlineRControl.java │ │ │ ├── simplifier │ │ │ │ └── ScalarizeVectorAssignments.java │ │ │ └── varState.java │ │ ├── main │ │ │ ├── PlatformLocalization.java │ │ │ ├── cmdline │ │ │ │ └── SketchOptions.java │ │ │ ├── other │ │ │ │ ├── ErrorHandling.java │ │ │ │ └── ParseFunctions.java │ │ │ ├── par │ │ │ │ ├── ParallelSketchMain.java │ │ │ │ ├── ParallelSketchOptions.java │ │ │ │ ├── RandomParallelSketchMain.java │ │ │ │ └── old │ │ │ │ │ ├── ToPSbit.java │ │ │ │ │ └── ToSpin.java │ │ │ ├── passes │ │ │ │ ├── CleanupFinalCode.java │ │ │ │ ├── LowerToSketch.java │ │ │ │ ├── MetaStage.java │ │ │ │ ├── OutputCCode.java │ │ │ │ ├── ParseProgramStage.java │ │ │ │ ├── PreprocessStage.java │ │ │ │ ├── StencilTransforms.java │ │ │ │ ├── SubstituteSolution.java │ │ │ │ └── TruncateVarArray.java │ │ │ ├── seq │ │ │ │ ├── CommonSketchMain.java │ │ │ │ ├── CompilerStage.java │ │ │ │ ├── SMTSketchOptions.java │ │ │ │ └── SequentialSketchMain.java │ │ │ └── sten │ │ │ │ ├── StencilSketchMain.java │ │ │ │ └── StencilSmtSketchMain.java │ │ ├── parallelEncoder │ │ │ ├── AtomizeConditionals.java │ │ │ ├── BreakParallelFunction.java │ │ │ ├── CFGSimplifier.java │ │ │ ├── CFGforPloop.java │ │ │ ├── ExtractPreParallelSection.java │ │ │ ├── LockPreprocessing.java │ │ │ ├── MinimizeLocals.java │ │ │ ├── ParallelPreprocessor.java │ │ │ ├── ProduceParallelModel.java │ │ │ └── VarSetReplacer.java │ │ ├── parser │ │ │ ├── Regen.java │ │ │ ├── RegenParser.java │ │ │ ├── StreamItLex.java │ │ │ ├── StreamItLexTokenTypes.java │ │ │ ├── StreamItParser.java │ │ │ ├── StreamItParserFE.java │ │ │ └── StreamItParserFETokenTypes.java │ │ ├── passes │ │ │ ├── annotations │ │ │ │ └── CompilerPassDeps.java │ │ │ ├── bidirectional │ │ │ │ ├── BidirectionalAnalysis.java │ │ │ │ ├── BidirectionalPass.java │ │ │ │ ├── EliminateLambdas.java │ │ │ │ ├── InnerFunReplacer.java │ │ │ │ ├── RemoveFunctionParameters.java │ │ │ │ ├── ThreadClosure.java │ │ │ │ └── TypeCheck.java │ │ │ ├── cleanup │ │ │ │ ├── CleanupRemoveMinFcns.java │ │ │ │ ├── EliminateAliasesInRefParams.java │ │ │ │ ├── MakeCastsExplicit.java │ │ │ │ ├── RemoveDumbArrays.java │ │ │ │ └── RemoveUselessCasts.java │ │ │ ├── cuda │ │ │ │ ├── CopyCudaMemTypeToFcnReturn.java │ │ │ │ ├── CudaCallGraph.java │ │ │ │ ├── DeleteCudaSyncthreads.java │ │ │ │ ├── DeleteInstrumentCalls.java │ │ │ │ ├── FlattenStmtBlocks2.java │ │ │ │ ├── GenerateAllOrSomeThreadsFunctions.java │ │ │ │ ├── GlobalToLocalImplicitCasts.java │ │ │ │ ├── InstrumentFcnCall.java │ │ │ │ ├── LowerInstrumentation.java │ │ │ │ ├── ReplaceBlockDimAndGridDim.java │ │ │ │ ├── ReplaceParforLoops.java │ │ │ │ ├── SetDefaultCudaMemoryTypes.java │ │ │ │ └── SplitAssignFromVarDef.java │ │ │ ├── lowering │ │ │ │ ├── AddArraySizeAssertions.java │ │ │ │ ├── AddInitializers.java │ │ │ │ ├── AddLastAssignmentToFork.java │ │ │ │ ├── AddPkgNameToNames.java │ │ │ │ ├── AssembleInitializers.java │ │ │ │ ├── AtomizeStatements.java │ │ │ │ ├── BackendCleanup.java │ │ │ │ ├── BlockifyRewriteableStmts.java │ │ │ │ ├── BoundUnboundedLoops.java │ │ │ │ ├── CollectFunCallsToCombine.java │ │ │ │ ├── CollectGlobalTags.java │ │ │ │ ├── CollectStmtTags.java │ │ │ │ ├── ConstantReplacer.java │ │ │ │ ├── ConvertVoidReturnTypesToBit.java │ │ │ │ ├── DisambiguateUnaries.java │ │ │ │ ├── EliminateArrayDims.java │ │ │ │ ├── EliminateArrayRange.java │ │ │ │ ├── EliminateBitSelector.java │ │ │ │ ├── EliminateComplexForLoops.java │ │ │ │ ├── EliminateConditionals.java │ │ │ │ ├── EliminateFinalStructs.java │ │ │ │ ├── EliminateGenerics.java │ │ │ │ ├── EliminateHugeArrays.java │ │ │ │ ├── EliminateImmutableStructs.java │ │ │ │ ├── EliminateInsertBlocks.java │ │ │ │ ├── EliminateLockUnlock.java │ │ │ │ ├── EliminateMDCopies.java │ │ │ │ ├── EliminateMultiDimArrays.java │ │ │ │ ├── EliminateNestedArrAcc.java │ │ │ │ ├── EliminateNestedTupleReads.java │ │ │ │ ├── EliminateNestedTuples.java │ │ │ │ ├── EliminateRegens.java │ │ │ │ ├── EliminateReorderBlocks.java │ │ │ │ ├── EliminateReturns.java │ │ │ │ ├── EliminateStructs.java │ │ │ │ ├── EliminateUnboxedStructs.java │ │ │ │ ├── EliminateZeroArrays.java │ │ │ │ ├── ExprTools.java │ │ │ │ ├── ExtractComplexFunParams.java │ │ │ │ ├── ExtractComplexLoopConditions.java │ │ │ │ ├── ExtractRightShifts.java │ │ │ │ ├── ExtractVectorsInCasts.java │ │ │ │ ├── FindFreeVariables.java │ │ │ │ ├── FlattenStmtBlocks.java │ │ │ │ ├── FunctionParamExtension.java │ │ │ │ ├── GetExprType.java │ │ │ │ ├── GetUsedStructs.java │ │ │ │ ├── GlobalsToParams.java │ │ │ │ ├── HoistDeclarations.java │ │ │ │ ├── LoopInvariantAssertionHoisting.java │ │ │ │ ├── LowerLoopsToWhileLoops.java │ │ │ │ ├── MakeAllocsAtomic.java │ │ │ │ ├── MakeBodiesBlocks.java │ │ │ │ ├── MakeLoopsRecursive.java │ │ │ │ ├── MakeMultiDimExplicit.java │ │ │ │ ├── MergeADT.java │ │ │ │ ├── MergeLocalStatements.java │ │ │ │ ├── NumberStatements.java │ │ │ │ ├── OptimizeADT.java │ │ │ │ ├── PreprocessForLoop.java │ │ │ │ ├── ProtectDangerousExprsAndShortCircuit.java │ │ │ │ ├── ReinterpretAssumes.java │ │ │ │ ├── RenameBitVars.java │ │ │ │ ├── ReplaceImplicitVarDecl.java │ │ │ │ ├── ReplaceSketchesWithSpecs.java │ │ │ │ ├── ScrubStructType.java │ │ │ │ ├── SemanticChecker.java │ │ │ │ ├── SeparateInitializers.java │ │ │ │ ├── SimpleLoopUnroller.java │ │ │ │ ├── SymbolTableVisitor.java │ │ │ │ ├── TrimDumbDeadCode.java │ │ │ │ ├── UnrollLocalLoops.java │ │ │ │ ├── VariableDeclarationMover.java │ │ │ │ └── VariableDisambiguator.java │ │ │ ├── optimization │ │ │ │ ├── AbstractCostFcnAssert.java │ │ │ │ ├── CostFcnAssert.java │ │ │ │ └── ReplaceMinLoops.java │ │ │ ├── preprocessing │ │ │ │ ├── BitTypeRemover.java │ │ │ │ ├── BitVectorPreprocessor.java │ │ │ │ ├── BuiltinFcnCall.java │ │ │ │ ├── CombineFunctionCalls.java │ │ │ │ ├── ConvertArrayAssignmentsToInout.java │ │ │ │ ├── CreateHarnesses.java │ │ │ │ ├── DisambiguateCallsAndTypeCheck.java │ │ │ │ ├── EliminateEmptyArrayLen.java │ │ │ │ ├── EliminateFieldHoles.java │ │ │ │ ├── EliminateListOfFieldsMacro.java │ │ │ │ ├── EliminateTripleEquals.java │ │ │ │ ├── ExpandRepeatCases.java │ │ │ │ ├── ExpressionCastingReplacer.java │ │ │ │ ├── ForbidArrayAssignmentInFcns.java │ │ │ │ ├── ForbidStarsInFieldDecls.java │ │ │ │ ├── LocalVariablesReplacer.java │ │ │ │ ├── MainMethodCreateNospec.java │ │ │ │ ├── MethodRename.java │ │ │ │ ├── MinimizeFcnCall.java │ │ │ │ ├── NamedTupleFcnCall.java │ │ │ │ ├── RemoveADTHoles.java │ │ │ │ ├── RemoveFunctionParameters.java │ │ │ │ ├── RemoveShallowTempVars.java │ │ │ │ ├── SetDeterministicFcns.java │ │ │ │ ├── TypeInferenceForADTHoles.java │ │ │ │ ├── cuda │ │ │ │ │ ├── SyncthreadsCall.java │ │ │ │ │ └── ThreadIdReplacer.java │ │ │ │ └── spmd │ │ │ │ │ ├── PidReplacer.java │ │ │ │ │ └── SpmdbarrierCall.java │ │ │ ├── printers │ │ │ │ ├── CodePrinter.java │ │ │ │ ├── CodePrinterVisitor.java │ │ │ │ ├── DumpAST.java │ │ │ │ ├── FunctionDeclPrinter.java │ │ │ │ └── SimpleCodePrinter.java │ │ │ ├── spmd │ │ │ │ ├── ChangeGlobalStateType.java │ │ │ │ ├── GlobalToLocalCasts.java │ │ │ │ ├── ReplaceParamExprArrayRange.java │ │ │ │ └── SpmdTransform.java │ │ │ ├── structure │ │ │ │ ├── ASTObjQuery.java │ │ │ │ ├── ASTQuery.java │ │ │ │ ├── CallGraph.java │ │ │ │ ├── ContainsCudaCode.java │ │ │ │ ├── ContainsStencilFunction.java │ │ │ │ ├── GetAssignLHS.java │ │ │ │ ├── GetImplementedFcns.java │ │ │ │ ├── GetPrintFcns.java │ │ │ │ ├── HasMinimize.java │ │ │ │ └── TprintIdentifier.java │ │ │ └── types │ │ │ │ └── CheckProperFinality.java │ │ ├── solvers │ │ │ ├── CEtrace.java │ │ │ ├── CompilationStatistics.java │ │ │ ├── CounterExample.java │ │ │ ├── InteractiveSATBackend.java │ │ │ ├── RandomSynthesizer.java │ │ │ ├── SATBackend.java │ │ │ ├── SATSolutionStatistics.java │ │ │ ├── SATSynthesizer.java │ │ │ ├── SolutionStatistics.java │ │ │ ├── SolverStatistics.java │ │ │ ├── SpinSolutionStatistics.java │ │ │ ├── SpinVerifier.java │ │ │ ├── Statistics.java │ │ │ ├── Synthesizer.java │ │ │ ├── Verifier.java │ │ │ ├── constructs │ │ │ │ ├── AbstractValueOracle.java │ │ │ │ ├── HoleNameTracker.java │ │ │ │ ├── RandomValueOracle.java │ │ │ │ ├── StaticHoleTracker.java │ │ │ │ └── ValueOracle.java │ │ │ └── parallel │ │ │ │ ├── ATimeStrategy.java │ │ │ │ ├── AsyncWilcoxonStrategy.java │ │ │ │ ├── AsyncWorker.java │ │ │ │ ├── IAsyncManager.java │ │ │ │ ├── IStrategy.java │ │ │ │ ├── MaxTimeStrategy.java │ │ │ │ ├── MinTimeStrategy.java │ │ │ │ ├── ParallelBackend.java │ │ │ │ ├── StrategicalBackend.java │ │ │ │ └── WilcoxonStrategy.java │ │ ├── spin │ │ │ ├── Configuration.java │ │ │ ├── EliminateDeadParallelCode.java │ │ │ ├── Executer.java │ │ │ ├── IdentifyModifiedVars.java │ │ │ ├── Preprocessor.java │ │ │ ├── PromelaCodePrinter.java │ │ │ └── SimpleCleanup.java │ │ ├── stencilSK │ │ │ ├── AbstractArray.java │ │ │ ├── ArrFunction.java │ │ │ ├── AssignStruct.java │ │ │ ├── BuildAbstractArrays.java │ │ │ ├── EliminateCompoundAssignments.java │ │ │ ├── EliminateReferenceParameters.java │ │ │ ├── EliminateStarStatic.java │ │ │ ├── ExpandBinMax.java │ │ │ ├── FunctionalizeStencils.java │ │ │ ├── MatchParamNames.java │ │ │ ├── ParamTree.java │ │ │ ├── ResolveMax.java │ │ │ ├── StmtMax.java │ │ │ ├── VarReplacer.java │ │ │ └── preprocessor │ │ │ │ ├── ReplaceFloatsWithBits.java │ │ │ │ ├── ReplaceFloatsWithFiniteField.java │ │ │ │ ├── ReplaceFloatsWithFixpoint.java │ │ │ │ └── ReplaceFloatsWithUFuns.java │ │ └── util │ │ │ └── DebugDumpProgram.java │ │ └── util │ │ ├── AssertedClass.java │ │ ├── CPreprocessedFileStream.java │ │ ├── Comperator.java │ │ ├── ControlFlowException.java │ │ ├── DLList.java │ │ ├── DLListElement.java │ │ ├── DLListIterator.java │ │ ├── DLList_const.java │ │ ├── DebugOut.java │ │ ├── DisjointSet.java │ │ ├── Fraction.java │ │ ├── HashComperator.java │ │ ├── IPredicate.java │ │ ├── InteractiveTimedProcess.java │ │ ├── InterceptedOutputStream.java │ │ ├── Misc.java │ │ ├── NullStream.java │ │ ├── Numerical.java │ │ ├── OMap.java │ │ ├── OMapIterator.java │ │ ├── OSet.java │ │ ├── OSetIterator.java │ │ ├── Pair.java │ │ ├── ProcessKillerThread.java │ │ ├── ProcessStatus.java │ │ ├── RBNode.java │ │ ├── RBTree.java │ │ ├── ScCloneable.java │ │ ├── Stopwatch.java │ │ ├── StrictlyMonotonicTime.java │ │ ├── SynchronousTimedProcess.java │ │ ├── Toolbox.java │ │ ├── TruncatedOutputStream.java │ │ ├── UndirectedColoredGraph.java │ │ ├── UniquePairContainer.java │ │ ├── annot │ │ ├── CodeGenerator.java │ │ └── ScGenerateWith.java │ │ ├── cli │ │ ├── CliAnnotatedOptionGroup.java │ │ ├── CliOption.java │ │ ├── CliOptionGroup.java │ │ ├── CliOptionResult.java │ │ ├── CliOptionType.java │ │ ├── CliOptional.java │ │ ├── CliParameter.java │ │ ├── CliParser.java │ │ └── SketchCliParser.java │ │ ├── cuda │ │ └── CudaThreadBlockDim.java │ │ ├── datastructures │ │ ├── CmdLineHashSet.java │ │ ├── DefaultNiceObj.java │ │ ├── FactoryStack.java │ │ ├── FilteredQueue.java │ │ ├── HashmapList.java │ │ ├── HashmapSet.java │ │ ├── ImmutablePair.java │ │ ├── ImmutableTypedHashMap.java │ │ ├── IntRange.java │ │ ├── LockableVector.java │ │ ├── LongHashObject.java │ │ ├── NiceLong.java │ │ ├── NiceObj.java │ │ ├── NiceString.java │ │ ├── ObjPairBase.java │ │ ├── ObjTuple3Base.java │ │ ├── ObjectFactory.java │ │ ├── OrderedHashSet.java │ │ ├── TprintTuple.java │ │ ├── TreemapSet.java │ │ ├── TypedHashMap.java │ │ ├── TypedHashSet.java │ │ └── TypedTreeMap.java │ │ ├── exceptions │ │ ├── ExceptionAtNode.java │ │ ├── InternalSketchException.java │ │ ├── LastGoodProgram.java │ │ ├── NotImplementedException.java │ │ ├── ProgramParseException.java │ │ ├── SketchException.java │ │ ├── SketchNotResolvedException.java │ │ ├── SketchSolverException.java │ │ ├── TypeErrorException.java │ │ ├── UnrecognizedVariableException.java │ │ └── UnsupportedSketchException.java │ │ ├── fcns │ │ ├── CopyableIterator.java │ │ ├── IsChanging.java │ │ ├── LazyMap.java │ │ ├── ScArrayUtil.java │ │ ├── ScHtmlUtil.java │ │ ├── VectorMap.java │ │ ├── Zip.java │ │ ├── ZipEnt.java │ │ ├── ZipIdxEnt.java │ │ └── ZipWithIndex.java │ │ ├── gui │ │ ├── ScInputDialogs.java │ │ └── Vector4.java │ │ ├── thread │ │ ├── AsyncMTEvent.java │ │ ├── InteractiveThread.java │ │ ├── MTReachabilityCheck.java │ │ └── MTSafe.java │ │ └── wrapper │ │ ├── EntireFileReader.java │ │ └── ScRichString.java └── other │ └── sketch │ └── compiler │ ├── parser │ ├── Regen.rats │ ├── StreamItLex.g │ ├── StreamItLexTokenTypes.txt │ ├── StreamItParserFE.g │ └── StreamItParserFETokenTypes.txt │ └── tosbit │ ├── acg.py │ └── array.tem ├── release_benchmarks ├── ImProcDemo │ ├── Img │ │ ├── Image.skh │ │ ├── ImgHelper.cpp │ │ └── ImgHelper.h │ ├── cmd │ ├── driver.cpp │ └── edgeDetector.sk ├── ImageProc │ ├── Img │ │ ├── Image.skh │ │ ├── ImgHelper.cpp │ │ ├── ImgHelper.h │ │ ├── scaleDown.skh │ │ ├── scaleUp.skh │ │ └── transforms.skh │ ├── ImgHelper.cpp │ ├── driver.cpp │ ├── driver2.cpp │ ├── matTransform.sk │ ├── scale.sk │ ├── test1.sk │ └── testb.bmp ├── gallery │ ├── CG.sk │ ├── HashSetComplete.skh │ ├── Pollard.sk │ ├── SetTest.sk │ ├── TreeSet.skh │ ├── compress.sk │ ├── diagStencil.sk │ ├── diagStencilClean.sk │ ├── doublyLinkedList.sk │ ├── enqueueSeqSK.sk │ ├── invariant.sk │ ├── isolateRightmost.sk │ ├── jburnim_morton.sk │ ├── karatsuba.sk │ ├── listReverse.sk │ ├── log2.sk │ ├── logcount.sk │ ├── lss.sk │ ├── neohookean.sk │ ├── parity.sk │ ├── partition.sk │ ├── polynomial.sk │ ├── registerlesSwap.sk │ ├── reverse.sk │ ├── runBenchmarks.sh │ ├── signedAvg.sk │ ├── sort.sk │ ├── sparse.skh │ ├── tableBasedAddition.sk │ ├── tutorial1.sk │ ├── tutorial2.sk │ ├── tutorial3.sk │ └── xpose.sk ├── performance_benchmarks │ ├── compute_deriv_sketch_files │ │ ├── 10.sk │ │ ├── 107.sk │ │ ├── 109.sk │ │ ├── 110.sk │ │ ├── 111.sk │ │ ├── 17.sk │ │ ├── 19.sk │ │ ├── 20.sk │ │ ├── 27.sk │ │ ├── 29.sk │ │ ├── 30.sk │ │ ├── 32.sk │ │ ├── 35.sk │ │ ├── 36.sk │ │ ├── 51.sk │ │ ├── 53.sk │ │ ├── 54.sk │ │ ├── 55.sk │ │ ├── 56.sk │ │ ├── 57.sk │ │ ├── 63.sk │ │ ├── 7.sk │ │ ├── 70.sk │ │ ├── 71.sk │ │ ├── 77.sk │ │ ├── 79.sk │ │ ├── 80.sk │ │ ├── 81.sk │ │ ├── 83.sk │ │ ├── 84.sk │ │ ├── demo2.py.sk │ │ ├── demo3.py.sk │ │ ├── demo4.py.sk │ │ └── demo5.py.sk │ ├── geometry │ │ ├── common.skh │ │ ├── geom16.sk │ │ ├── geom21.sk │ │ ├── geom31.sk │ │ ├── geom38.sk │ │ ├── geom39.sk │ │ ├── geom64.sk │ │ ├── geom73.sk │ │ ├── geom75.sk │ │ ├── geom82.sk │ │ ├── geom92.sk │ │ └── geom99.sk │ ├── imp_synt_benchmarks │ │ ├── bst_header.skh │ │ ├── bst_insert_rec.sk │ │ ├── helper.skh │ │ ├── insertion_sort_rec.sk │ │ ├── lseg_header.skh │ │ ├── sll_length_count.sk │ │ ├── sll_max.sk │ │ ├── sll_min.sk │ │ └── srtl_insert_rec.sk │ ├── phonologySketches │ │ ├── common.skh │ │ ├── tmp6GYoLU.sk │ │ ├── tmpClf9K5.sk │ │ ├── tmpcTj5TJ.sk │ │ └── tmpggspN7.sk │ ├── qbs │ │ ├── ActivityService.sk │ │ ├── ActivityService2.sk │ │ ├── ConcreteActivityService.sk │ │ ├── ConcreteRoleAffectationService.sk │ │ ├── GuidanceService.sk │ │ ├── GuidanceService2.sk │ │ ├── IssueServiceImpl.sk │ │ ├── IterationService.sk │ │ ├── LoginService.sk │ │ ├── LoginService2.sk │ │ ├── NotificationServiceImpl2.sk │ │ ├── PhaseService.sk │ │ ├── ProcessBean.sk │ │ ├── ProjectService3.sk │ │ └── UserServiceImpl.sk │ └── storyboard_benchmarks │ │ ├── scenarios_aig_insertion1.sb.pl.sk │ │ ├── scenarios_aig_insertion2.sb.pl.sk │ │ ├── scenarios_aig_traverse.sb.pl.sk │ │ ├── scenarios_lldelete1.sb.pl.sk │ │ ├── scenarios_llinsert2.sb.pl.sk │ │ ├── scenarios_llreverse.sb.pl.sk │ │ ├── scenarios_lltraversal.sb.pl.sk │ │ ├── scenarios_tree_delete.sb.pl.sk │ │ ├── scenarios_tree_delete1.sb.pl.sk │ │ ├── scenarios_tree_delete2.sb.pl.sk │ │ ├── scenarios_tree_delete3.sb.pl.sk │ │ ├── scenarios_tree_delete4.sb.pl.sk │ │ ├── scenarios_tree_insert_insert.sb.pl.sk │ │ ├── scenarios_tree_insert_search.sb.pl.sk │ │ ├── scenarios_tree_search.sb.pl.sk │ │ ├── scenarios_treemax.sb.pl.sk │ │ └── scenarios_treemin.sb.pl.sk ├── perftest.sh └── sk │ ├── HashSetComplete.skh │ ├── Makefile │ ├── Pollard.sk │ ├── SetTest.sk │ ├── TreeSet.skh │ ├── clean.sh │ ├── compress.sk │ ├── compress2.sk │ ├── doublyLinkedList.sk │ ├── dsChallenges │ └── redBlackTree4.sk │ ├── effectsOfOptims.sh │ ├── enqueueSeqSK.sk │ ├── hardSort.sk │ ├── harder │ ├── dutchFlag.sk │ ├── jburnim_morton.sk │ ├── karatsuba.sk │ ├── karatsuba_c2_i2.sk │ ├── karatsuba_c3_i2.sk │ ├── xpose.sk │ └── xposeBit.sk │ ├── isolateRightmost.sk │ ├── isolateRightmostFancy.sk │ ├── jburnim_morton_easier.sk │ ├── jburnim_morton_easiest.sk │ ├── listReverseEasy.sk │ ├── listReverseHarder.sk │ ├── log2.sk │ ├── log2VarLoop.sk │ ├── logcount.sk │ ├── logcount2.sk │ ├── lss.sk │ ├── lssBig.sk │ ├── lss_harder.sk │ ├── medium │ ├── prefix_sum-no-headers.sk │ ├── prefix_sum_instr-no-headers.sk │ └── prefix_sum_localized-no-headers.sk │ ├── parity.sk │ ├── polynomial.sk │ ├── produceShowroom.sh │ ├── registerlesSwap.sk │ ├── regtest.sh │ ├── regtest2.sh │ ├── reverse.sk │ ├── runBenchmarks.sh │ ├── runkar.sh │ ├── sketch2html.sh │ ├── sten │ ├── cacheObv1d4.sk │ ├── distribute2d.sk │ ├── mgInterpBlock.sk │ ├── mgInterpFast.sk │ ├── rb3d.sk │ ├── rb3dSimpleOdd.sk │ ├── timeSkewing3.sk │ └── timeSkewing4.sk │ ├── tableBasedAddition.sk │ ├── troubleBenchs.sh │ ├── tutorial1.sk │ ├── tutorial2.sk │ └── tutorial3.sk ├── resources └── filtered │ └── sketch │ └── compiler │ └── resources │ └── localization.properties ├── runtime └── include │ ├── Makefile │ ├── bitvec.h │ ├── bvtest.cc │ ├── fixedarr.h │ ├── fopen.h │ ├── fread.h │ ├── isEmpty.h │ ├── readStr.h │ ├── spmd.h │ └── vops.h ├── sketchlib ├── array.skh ├── boundedgen.skh ├── boundedopr.py ├── boundedopr.skh ├── filehandler.skh ├── generators.skh ├── generators2.skh ├── generics.skh ├── intops.skh ├── list.skh ├── math.skh ├── signedbv.skh ├── spmd.skh ├── stack.skh ├── string.skh └── vec2d.skh ├── test ├── deprecated │ ├── agmax │ │ ├── test_angelic_max.sk │ │ ├── test_angelic_max2.sk │ │ ├── test_angelic_max3.sk │ │ └── test_angelic_max4.sk │ ├── java │ │ └── sketch │ │ │ └── compiler │ │ │ ├── seq │ │ │ ├── BinTree.java │ │ │ ├── SketchRegressionTests.java │ │ │ ├── SketchShowcase.java │ │ │ └── StencilShowcase.java │ │ │ └── smt │ │ │ ├── AllTests.java │ │ │ ├── HoleSorter.java │ │ │ ├── TestHarness.java │ │ │ ├── beaver │ │ │ └── LanguageBasicBlastBV.java │ │ │ ├── cvc3 │ │ │ ├── AllTests.java │ │ │ ├── BenchmarkTests.java │ │ │ ├── LanguageBasicBlastBV.java │ │ │ ├── LanguageBasicBlastInt.java │ │ │ ├── LanguageBasicTOABV.java │ │ │ ├── LanguageBasicTOAInt.java │ │ │ ├── LoopBlastBV.java │ │ │ ├── LoopBlastInt.java │ │ │ ├── LoopTOABV.java │ │ │ ├── LoopTOAInt.java │ │ │ ├── RegularExprBlastBV.java │ │ │ ├── RegularExprBlastInt.java │ │ │ ├── RegularExprTOABV.java │ │ │ └── RegularExprTOAInt.java │ │ │ ├── cvc3smtlib │ │ │ ├── LanguageBasicBlastBV.java │ │ │ └── RegularExprTests.java │ │ │ ├── sbit │ │ │ ├── RepeatSketchSuite.java │ │ │ ├── RepeatStencilShowcase.java │ │ │ ├── SketchRegressionTests.java │ │ │ ├── SketchShowcase.java │ │ │ └── StencilShowcase.java │ │ │ ├── stp │ │ │ ├── AllSTPTests.java │ │ │ ├── BinTree.java │ │ │ ├── BitVectorBlastBV.java │ │ │ ├── CompareCSESuite.java │ │ │ ├── FailedStencilRegression.java │ │ │ ├── LanguageBasic.java │ │ │ ├── LanguageBasicBlastBV.java │ │ │ ├── LanguageBasicCanonFHBlastBV.java │ │ │ ├── LanguageBasicCanonFHTOABV.java │ │ │ ├── LanguageBasicFHBlastBV.java │ │ │ ├── LanguageBasicTOABV.java │ │ │ ├── LinkedListReversal.java │ │ │ ├── Opt.java │ │ │ ├── RegularExprBlastBV.java │ │ │ ├── RepeatSketchBlastBVSuite.java │ │ │ ├── RepeatSketchTOABVSuite.java │ │ │ ├── SketchRegressionBlastBV.java │ │ │ ├── SketchRegressionCanonFHBlastBV.java │ │ │ ├── SketchRegressionCanonFHTOABV.java │ │ │ ├── SketchRegressionFHBlastBV.java │ │ │ ├── SketchRegressionSuite.java │ │ │ ├── SketchRegressionTOABV.java │ │ │ ├── SketchShowcaseBlastBV.java │ │ │ ├── SketchShowcaseCSE2CanonFHBlastBV.java │ │ │ ├── SketchShowcaseCSECanonFHBlastBV.java │ │ │ ├── SketchShowcaseCanonFHBlastBV.java │ │ │ ├── SketchShowcaseCanonFHTOABV.java │ │ │ ├── SketchShowcaseFHBlastBV.java │ │ │ ├── SketchShowcaseSuite.java │ │ │ ├── SketchShowcaseTOABV.java │ │ │ ├── StenRegressionTests.java │ │ │ └── StencilShowcaseCanonFHBlastBV.java │ │ │ ├── stpyices │ │ │ ├── RepeatSketchSuite.java │ │ │ ├── SketchShowcaseBlastBV.java │ │ │ └── StencilShowcaseCanonFHBlastBV.java │ │ │ ├── tests │ │ │ ├── BinTree.java │ │ │ ├── BitVectorBlastBV.java │ │ │ ├── LanguageBasicBlastBV.java │ │ │ ├── LanguageBasicBlastInt.java │ │ │ ├── LanguageBasicCanonFHBlastBV.java │ │ │ ├── LanguageBasicCanonFHTOABV.java │ │ │ ├── LanguageBasicFHBlastBV.java │ │ │ ├── LanguageBasicTOABV.java │ │ │ ├── LinkedListReversal.java │ │ │ ├── Opt.java │ │ │ ├── RegularExprBlastBV.java │ │ │ ├── SketchRegressionBlastBV.java │ │ │ ├── SketchRegressionCanonFHBlastBV.java │ │ │ ├── SketchRegressionCanonFHTOABV.java │ │ │ ├── SketchRegressionFHBlastBV.java │ │ │ ├── SketchRegressionTOABV.java │ │ │ ├── SketchShowcaseBlastBV.java │ │ │ ├── SketchShowcaseCSE2CanonFHBlastBV.java │ │ │ ├── SketchShowcaseCSECanonFHBlastBV.java │ │ │ ├── SketchShowcaseCanonFHBlastBV.java │ │ │ ├── SketchShowcaseCanonFHTOABV.java │ │ │ ├── SketchShowcaseFHBlastBV.java │ │ │ ├── SketchShowcaseTOABV.java │ │ │ ├── StenRegressionTests.java │ │ │ ├── StencilOptBlastBV.java │ │ │ ├── StencilOptCSECanonFHBlastBV.java │ │ │ ├── StencilOptCanonFHBlastBV.java │ │ │ ├── StencilShowcase.java │ │ │ └── StencilShowcaseCanonFHBlastBV.java │ │ │ ├── yices │ │ │ ├── AllTests.java │ │ │ ├── AllYicesTests.java │ │ │ ├── BinTree.java │ │ │ ├── BitVectorBlastBV.java │ │ │ ├── FailedRegression.java │ │ │ ├── FailedStencilRegression.java │ │ │ ├── LanguageBasicBlastBV.java │ │ │ ├── LanguageBasicTOABV.java │ │ │ ├── LinkedListReversal.java │ │ │ ├── LoopBlastBV.java │ │ │ ├── LoopTOABV.java │ │ │ ├── RegularExprBlastBV.java │ │ │ ├── RegularExprTOABV.java │ │ │ ├── SketchRegressionTests.java │ │ │ ├── SketchShowcase.java │ │ │ └── StenRegressionTests.java │ │ │ ├── yices2 │ │ │ ├── AllYices2Tests.java │ │ │ ├── BitVectorBlastBV.java │ │ │ ├── CompareCSESuite.java │ │ │ ├── LanguageBasic.java │ │ │ ├── LanguageBasicBlastBV.java │ │ │ ├── LanguageBasicBlastInt.java │ │ │ ├── LanguageBasicCanonFHBlastBV.java │ │ │ ├── LanguageBasicCanonFHTOABV.java │ │ │ ├── LanguageBasicFHBlastBV.java │ │ │ ├── LanguageBasicTOABV.java │ │ │ ├── RepeatSketchBlastBVSuite.java │ │ │ ├── RepeatSketchTOABVSuite.java │ │ │ ├── SketchRegressionBlastBV.java │ │ │ ├── SketchRegressionCanonFHBlastBV.java │ │ │ ├── SketchRegressionCanonFHTOABV.java │ │ │ ├── SketchRegressionFHBlastBV.java │ │ │ ├── SketchRegressionSuite.java │ │ │ ├── SketchRegressionTOABV.java │ │ │ ├── SketchShowcaseBlastBV.java │ │ │ ├── SketchShowcaseCSE2CanonFHBlastBV.java │ │ │ ├── SketchShowcaseCSECanonFHBlastBV.java │ │ │ ├── SketchShowcaseCanonFHBlastBV.java │ │ │ ├── SketchShowcaseCanonFHTOABV.java │ │ │ ├── SketchShowcaseFHBlastBV.java │ │ │ ├── SketchShowcaseSuite.java │ │ │ ├── SketchShowcaseTOABV.java │ │ │ ├── StenRegressionCanonFHBlastBV.java │ │ │ └── StencilShowcaseCanonFHBlastBV.java │ │ │ └── z3 │ │ │ ├── AllTests.java │ │ │ ├── BitVectorBlastBV.java │ │ │ ├── CompareCSESuite.java │ │ │ ├── FailedStencilRegression.java │ │ │ ├── LanguageBasicBlastBV.java │ │ │ ├── LanguageBasicTOABV.java │ │ │ ├── LoopBlastBV.java │ │ │ ├── LoopTOABV.java │ │ │ ├── RegularExprBlastBV.java │ │ │ ├── RepeatSketchBlastBVSuite.java │ │ │ ├── RepeatSketchTOABVSuite.java │ │ │ ├── SketchRegressionBlastBV.java │ │ │ ├── SketchShowcaseBlastBV.java │ │ │ ├── SketchShowcaseCSE2CanonFHBlastBV.java │ │ │ ├── SketchShowcaseCSECanonFHBlastBV.java │ │ │ ├── SketchShowcaseCanonFHBlastBV.java │ │ │ ├── SketchShowcaseCanonFHTOABV.java │ │ │ ├── SketchShowcaseFHBlastBV.java │ │ │ ├── SketchShowcaseSuite.java │ │ │ ├── SketchShowcaseTOABV.java │ │ │ ├── StenRegressionTests.java │ │ │ └── StencilShowcaseCanonFHBlastBV.java │ ├── par │ │ ├── Makefile │ │ ├── clean.sh │ │ ├── errorHandling │ │ │ └── miniTest1.sk │ │ ├── miniTest1.sk │ │ ├── miniTest10.sk │ │ ├── miniTest11.sk │ │ ├── miniTest12.sk │ │ ├── miniTest13.sk │ │ ├── miniTest14.sk │ │ ├── miniTest15.sk │ │ ├── miniTest16.sk │ │ ├── miniTest17.sk │ │ ├── miniTest18.sk │ │ ├── miniTest19.sk │ │ ├── miniTest2.sk │ │ ├── miniTest20.sk │ │ ├── miniTest21.sk │ │ ├── miniTest22.sk │ │ ├── miniTest23.sk │ │ ├── miniTest24.sk │ │ ├── miniTest25.sk │ │ ├── miniTest26.sk │ │ ├── miniTest27.sk │ │ ├── miniTest28.sk │ │ ├── miniTest29.sk │ │ ├── miniTest3.sk │ │ ├── miniTest30.sk │ │ ├── miniTest31.sk │ │ ├── miniTest32.sk │ │ ├── miniTest33.sk │ │ ├── miniTest34.sk │ │ ├── miniTest35.sk │ │ ├── miniTest36.sk │ │ ├── miniTest37.sk │ │ ├── miniTest38.sk │ │ ├── miniTest39.sk │ │ ├── miniTest4.sk │ │ ├── miniTest40.sk │ │ ├── miniTest41.sk │ │ ├── miniTest42.sk │ │ ├── miniTest43.sk │ │ ├── miniTest44.sk │ │ ├── miniTest45.sk │ │ ├── miniTest46.sk │ │ ├── miniTest47.sk │ │ ├── miniTest48.sk │ │ ├── miniTest49.sk │ │ ├── miniTest5.sk │ │ ├── miniTest50.sk │ │ ├── miniTest51.sk │ │ ├── miniTest52.sk │ │ ├── miniTest53.sk │ │ ├── miniTest54.sk │ │ ├── miniTest55.sk │ │ ├── miniTest56.sk │ │ ├── miniTest57.sk │ │ ├── miniTest58.sk │ │ ├── miniTest59.sk │ │ ├── miniTest6.sk │ │ ├── miniTest60.sk │ │ ├── miniTest61.sk │ │ ├── miniTest62.sk │ │ ├── miniTest63.sk │ │ ├── miniTest64.sk │ │ ├── miniTest65.sk │ │ ├── miniTest66.sk │ │ ├── miniTest67.sk │ │ ├── miniTest68.sk │ │ ├── miniTest69.sk │ │ ├── miniTest7.sk │ │ ├── miniTest70.sk │ │ ├── miniTest8.sk │ │ ├── miniTest9.sk │ │ └── regtest.sh │ ├── smt │ │ ├── basics │ │ │ ├── array.sk │ │ │ ├── arrayAccessBottomIdx.sk │ │ │ ├── arrayAsFuncArg.sk │ │ │ ├── arrayAsInput.sk │ │ │ ├── arrayAssignToArray.sk │ │ │ ├── arrayBoundCheck.sk │ │ │ ├── arrayInit.sk │ │ │ ├── arrayInitWithStar.sk │ │ │ ├── arrayMultiDim.sk │ │ │ ├── arrayMultiDimHoleIndex.sk │ │ │ ├── arrayOfHoles.sk │ │ │ ├── arrayUpdateBottomIdx.sk │ │ │ ├── arrayUpdateToHole.sk │ │ │ ├── binaryDivide.sk │ │ │ ├── binaryDivideZero.sk │ │ │ ├── binaryOps.sk │ │ │ ├── binaryXOR.sk │ │ │ ├── boolType.sk │ │ │ ├── bvIf.sk │ │ │ ├── concat.sk │ │ │ ├── convertBitArrayToInt.sk │ │ │ ├── convertBitArrayToInt2.sk │ │ │ ├── convertBitArrayToInt3.sk │ │ │ ├── convertIntToBitArray.sk │ │ │ ├── empty.sk │ │ │ ├── extract.sk │ │ │ ├── funcCallDupRecursionEz.sk │ │ │ ├── funcCallDupRecursionHard.sk │ │ │ ├── funcCallRecursion.sk │ │ │ ├── functionCall.sk │ │ │ ├── holeWhile.sk │ │ │ ├── ifStmt.sk │ │ │ ├── ifStmtCEGIS.sk │ │ │ ├── ifStmtNested.sk │ │ │ ├── ifStmtWithArrayElemUpdate.sk │ │ │ ├── integerWhile.sk │ │ │ ├── integers.sk │ │ │ ├── integersIf.sk │ │ │ ├── integersIf2.sk │ │ │ ├── lshift.sk │ │ │ ├── multiAsserts.sk │ │ │ ├── negativeInt.sk │ │ │ ├── objectOneField.sk │ │ │ ├── objectThreeFields.sk │ │ │ ├── objectTwoFields.sk │ │ │ ├── objectWhile.sk │ │ │ ├── regExprObj2.sk │ │ │ ├── regexpr.sk │ │ │ ├── regexpr3.sk │ │ │ ├── smallWidthHole.sk │ │ │ ├── smallWidthHoleArrayUpdate.sk │ │ │ ├── typecast.sk │ │ │ ├── typecastFromBitBottom.sk │ │ │ ├── typecastFromBoolBottom.sk │ │ │ ├── typecastFromIntBottom.sk │ │ │ ├── unaryOpsBitNot.sk │ │ │ ├── unaryOpsLogicalNot.sk │ │ │ ├── unaryOpsNegation.sk │ │ │ └── varAssignment.sk │ │ ├── bitvectors │ │ │ ├── arrayAssignment.sk │ │ │ ├── bitselect.sk │ │ │ ├── castBigBitArrayToSmall.sk │ │ │ ├── castBottomScalarToBitArray.sk │ │ │ ├── castConstScalarToBitArray.sk │ │ │ ├── castSmallBitArrayToBig.sk │ │ │ ├── elementAccWithBottomIdx.sk │ │ │ ├── elementRangeAccWithConstRange.sk │ │ │ ├── elementRangeUpdateWithConstRange.sk │ │ │ ├── elementUpdateWithBottomIdx.sk │ │ │ ├── elementUpdateWithConstIdx.sk │ │ │ ├── hole.sk │ │ │ ├── init.sk │ │ │ └── vectorIndex.sk │ │ ├── opt │ │ │ ├── plus.sk │ │ │ └── plusMultiVar.sk │ │ ├── sketchTests │ │ │ ├── regtests │ │ │ │ ├── miniTest52.sk │ │ │ │ ├── miniTest76.sk │ │ │ │ ├── miniTest78.sk │ │ │ │ ├── miniTest80.sk │ │ │ │ ├── miniTestb124.sk │ │ │ │ ├── miniTestb151.sk │ │ │ │ ├── miniTestb152.sk │ │ │ │ ├── miniTestb163.sk │ │ │ │ └── miniTestb165.sk │ │ │ └── showcase │ │ │ │ ├── Pollard.sk │ │ │ │ ├── SpMV-COO1-N2-BIT.sk │ │ │ │ ├── SpMV-COO1-N2-INT.sk │ │ │ │ ├── SpMV-COO1-N3-BIT.sk │ │ │ │ ├── SpMV-COO1-N3-INT.sk │ │ │ │ ├── SpMV-COO1-N4-BIT.sk │ │ │ │ ├── SpMV-COO1-N4-INT.sk │ │ │ │ ├── SpMV-CSR1-N2-BIT.sk │ │ │ │ ├── SpMV-CSR1-N2-INT.sk │ │ │ │ ├── SpMV-CSR1-N3-BIT.sk │ │ │ │ ├── SpMV-CSR1-N3-INT.sk │ │ │ │ ├── SpMV-CSR1-N4-BIT.sk │ │ │ │ ├── SpMV-CSR1-N4-INT.sk │ │ │ │ ├── SpMV-CSR1-N5-BIT.sk │ │ │ │ ├── SpMV-CSR1-N5-INT.sk │ │ │ │ ├── SpMV-DIA1-N2-BIT.sk │ │ │ │ ├── SpMV-DIA1-N2-INT.sk │ │ │ │ ├── SpMV-DIA1-N3-BIT.sk │ │ │ │ ├── SpMV-DIA1-N3-INT.sk │ │ │ │ ├── SpMV-DIA1-N4-BIT.sk │ │ │ │ ├── SpMV-DIA1-N4-INT.sk │ │ │ │ ├── SpMV-DIA2-N2-BIT.sk │ │ │ │ ├── SpMV-DIA2-N2-INT.sk │ │ │ │ ├── SpMV-DIA2-N3-BIT.sk │ │ │ │ ├── SpMV-DIA2-N3-INT.sk │ │ │ │ ├── SpMV-DIA2-N4-BIT.sk │ │ │ │ ├── SpMV-DIA2-N4-INT.sk │ │ │ │ ├── SpMV-DIA2-N5-BIT.sk │ │ │ │ ├── SpMV-DIA2-N5-INT.sk │ │ │ │ ├── SpMV-DIA2-N6-BIT.sk │ │ │ │ ├── aesFullStage.sk │ │ │ │ ├── crc3.sk │ │ │ │ ├── des2.sk │ │ │ │ ├── fillArray.sk │ │ │ │ ├── hardSort.sk │ │ │ │ ├── logcount.sk │ │ │ │ ├── parity.sk │ │ │ │ ├── polynomialInt.sk │ │ │ │ ├── tableBasedAddition.sk │ │ │ │ ├── test04-binary-tree-faster.sk │ │ │ │ ├── testInit.sk │ │ │ │ ├── testUninit.sk │ │ │ │ ├── wallace-for-lexin-3.sk │ │ │ │ └── xpose.sk │ │ └── stenShowcase │ │ │ ├── cacheObv1d4.sk │ │ │ ├── distribute2d.sk │ │ │ ├── mgInterpBlock.sk │ │ │ ├── mgInterpFast.sk │ │ │ ├── rb3d.sk │ │ │ ├── rb3dSimpleOdd.sk │ │ │ ├── timeSkewing3.sk │ │ │ └── timeSkewing4.sk │ └── sten │ │ ├── Makefile │ │ ├── clean.sh │ │ ├── miniTest0.sk │ │ ├── miniTest1.sk │ │ ├── miniTest10.sk │ │ ├── miniTest11.sk │ │ ├── miniTest12.sk │ │ ├── miniTest13.sk │ │ ├── miniTest14.sk │ │ ├── miniTest15.sk │ │ ├── miniTest16.sk │ │ ├── miniTest17.sk │ │ ├── miniTest18.sk │ │ ├── miniTest19.sk │ │ ├── miniTest2.sk │ │ ├── miniTest20.sk │ │ ├── miniTest21.sk │ │ ├── miniTest22.sk │ │ ├── miniTest23.sk │ │ ├── miniTest24.sk │ │ ├── miniTest25.sk │ │ ├── miniTest26.sk │ │ ├── miniTest27.sk │ │ ├── miniTest28.sk │ │ ├── miniTest29.sk │ │ ├── miniTest3.sk │ │ ├── miniTest4.sk │ │ ├── miniTest5.sk │ │ ├── miniTest6.sk │ │ ├── miniTest7.sk │ │ ├── miniTest8.sk │ │ ├── miniTest9.sk │ │ ├── regtest-gilad.sh │ │ ├── regtest.sh │ │ └── regtest2.sh ├── java │ └── sketch │ │ └── compiler │ │ └── test │ │ ├── BasicFileFilter.java │ │ ├── MediumReleaseBenchmarks.java │ │ ├── QuickTest.java │ │ ├── SequentialJunitTest.java │ │ ├── SequentialSketchRunner.java │ │ ├── SketchRunner.java │ │ └── SketchTestSuite.java └── sk │ ├── numerical │ ├── Makefile │ ├── clean.sh │ ├── miniTestb01.sk │ ├── miniTestb02.sk │ ├── miniTestb03.sk │ ├── miniTestb04.sk │ ├── miniTestb05.sk │ ├── miniTestb06.sk │ ├── miniTestb07.sk │ ├── miniTestb08.sk │ ├── miniTestb09.sk │ ├── miniTestb10.sk │ ├── miniTestb11.sk │ ├── miniTestb12.sk │ ├── miniTestb13.sk │ ├── miniTestb14.sk │ ├── miniTestb16.sk │ ├── miniTestb17.sk │ ├── miniTestb18.sk │ ├── miniTestb19.sk │ ├── miniTestb20.sk │ ├── miniTestb20_segs.skh │ ├── miniTestb21.sk │ ├── miniTestb22.sk │ ├── miniTestb23.sk │ ├── miniTestb24.sk │ ├── miniTestb25.sk │ └── miniTestb26.sk │ ├── par.py │ ├── seq │ ├── ERSYNTH │ │ ├── miniTestERSyn1.sk │ │ ├── miniTestERSyn2.sk │ │ ├── miniTestERSyn3-simeval.table │ │ ├── miniTestERSyn3.sk │ │ └── miniTestERSyn4.sk │ ├── Makefile │ ├── clean.sh │ ├── miniTest1.sk │ ├── miniTest10.sk │ ├── miniTest11.sk │ ├── miniTest12.sk │ ├── miniTest13.sk │ ├── miniTest14.sk │ ├── miniTest15.sk │ ├── miniTest16.sk │ ├── miniTest17.sk │ ├── miniTest18.sk │ ├── miniTest19.sk │ ├── miniTest199Includes.sk │ ├── miniTest199Includes.skh │ ├── miniTest2.sk │ ├── miniTest20.sk │ ├── miniTest207MainMethodAndPragma.sk │ ├── miniTest208Globals.sk │ ├── miniTest209Globals.sk │ ├── miniTest21.sk │ ├── miniTest211ExprArrayInit.sk │ ├── miniTest212IndexOffsetBug.sk │ ├── miniTest213ArrExpScaling.sk │ ├── miniTest215Choice.sk │ ├── miniTest22.sk │ ├── miniTest23.sk │ ├── miniTest24.sk │ ├── miniTest25.sk │ ├── miniTest26.sk │ ├── miniTest28.sk │ ├── miniTest29.sk │ ├── miniTest3.sk │ ├── miniTest30.sk │ ├── miniTest31.sk │ ├── miniTest32.sk │ ├── miniTest33.sk │ ├── miniTest34.sk │ ├── miniTest35.sk │ ├── miniTest36.sk │ ├── miniTest37.sk │ ├── miniTest38.sk │ ├── miniTest39.sk │ ├── miniTest4.sk │ ├── miniTest40.sk │ ├── miniTest41.sk │ ├── miniTest42.sk │ ├── miniTest43.sk │ ├── miniTest44.sk │ ├── miniTest45.sk │ ├── miniTest46.sk │ ├── miniTest47.sk │ ├── miniTest48.sk │ ├── miniTest49.sk │ ├── miniTest5.sk │ ├── miniTest50.sk │ ├── miniTest51.sk │ ├── miniTest52.sk │ ├── miniTest53.sk │ ├── miniTest54.sk │ ├── miniTest55.sk │ ├── miniTest56.sk │ ├── miniTest57.sk │ ├── miniTest6.sk │ ├── miniTest60.sk │ ├── miniTest61.sk │ ├── miniTest62.sk │ ├── miniTest63.sk │ ├── miniTest64.sk │ ├── miniTest65.sk │ ├── miniTest66.sk │ ├── miniTest67.sk │ ├── miniTest68.sk │ ├── miniTest69.sk │ ├── miniTest7.sk │ ├── miniTest70.sk │ ├── miniTest71.sk │ ├── miniTest72.sk │ ├── miniTest73.sk │ ├── miniTest74.sk │ ├── miniTest75.sk │ ├── miniTest76.sk │ ├── miniTest77.sk │ ├── miniTest78.sk │ ├── miniTest79.sk │ ├── miniTest7small.sk │ ├── miniTest8.sk │ ├── miniTest80.sk │ ├── miniTest81.sk │ ├── miniTest82.sk │ ├── miniTest83.sk │ ├── miniTest84.sk │ ├── miniTest85.sk │ ├── miniTest86.sk │ ├── miniTest87.sk │ ├── miniTest88.sk │ ├── miniTest89.sk │ ├── miniTest9.sk │ ├── miniTest90.sk │ ├── miniTest91.sk │ ├── miniTest92.sk │ ├── miniTest93.sk │ ├── miniTest94.sk │ ├── miniTest95.sk │ ├── miniTest96.sk │ ├── miniTest97.sk │ ├── miniTest98.sk │ ├── miniTest99.sk │ ├── miniTestBigInts1.sk │ ├── miniTestBigInts2.sk │ ├── miniTestBigInts3.sk │ ├── miniTestBigInts5.sk │ ├── miniTestBigInts6.sk │ ├── miniTestBigInts7.sk │ ├── miniTestb100.sk │ ├── miniTestb101.sk │ ├── miniTestb102.sk │ ├── miniTestb103.sk │ ├── miniTestb104.sk │ ├── miniTestb105.sk │ ├── miniTestb106.sk │ ├── miniTestb107.sk │ ├── miniTestb108.sk │ ├── miniTestb109.sk │ ├── miniTestb110.sk │ ├── miniTestb111.sk │ ├── miniTestb112.sk │ ├── miniTestb113.sk │ ├── miniTestb114.sk │ ├── miniTestb116.sk │ ├── miniTestb117.sk │ ├── miniTestb118.sk │ ├── miniTestb120.sk │ ├── miniTestb121.sk │ ├── miniTestb122.sk │ ├── miniTestb123.sk │ ├── miniTestb124.sk │ ├── miniTestb125.sk │ ├── miniTestb126.sk │ ├── miniTestb127.sk │ ├── miniTestb128.sk │ ├── miniTestb129.sk │ ├── miniTestb130.sk │ ├── miniTestb131.sk │ ├── miniTestb132.sk │ ├── miniTestb133.sk │ ├── miniTestb134.sk │ ├── miniTestb135.sk │ ├── miniTestb136.sk │ ├── miniTestb137.sk │ ├── miniTestb138.sk │ ├── miniTestb139.sk │ ├── miniTestb140.sk │ ├── miniTestb141.sk │ ├── miniTestb142.sk │ ├── miniTestb143.sk │ ├── miniTestb144.sk │ ├── miniTestb145.sk │ ├── miniTestb146.sk │ ├── miniTestb147.sk │ ├── miniTestb148.sk │ ├── miniTestb149.sk │ ├── miniTestb150.sk │ ├── miniTestb151.sk │ ├── miniTestb152.sk │ ├── miniTestb153.sk │ ├── miniTestb154.sk │ ├── miniTestb155.sk │ ├── miniTestb156.sk │ ├── miniTestb157.sk │ ├── miniTestb158.sk │ ├── miniTestb159.sk │ ├── miniTestb160.sk │ ├── miniTestb161.sk │ ├── miniTestb162.sk │ ├── miniTestb163.sk │ ├── miniTestb164.sk │ ├── miniTestb165.sk │ ├── miniTestb166.sk │ ├── miniTestb167.sk │ ├── miniTestb168.sk │ ├── miniTestb169.sk │ ├── miniTestb170.sk │ ├── miniTestb171.sk │ ├── miniTestb172.sk │ ├── miniTestb173.sk │ ├── miniTestb174.sk │ ├── miniTestb175.sk │ ├── miniTestb176.sk │ ├── miniTestb177.sk │ ├── miniTestb178.sk │ ├── miniTestb179.sk │ ├── miniTestb180.sk │ ├── miniTestb181.sk │ ├── miniTestb182.sk │ ├── miniTestb183.sk │ ├── miniTestb184.sk │ ├── miniTestb185.sk │ ├── miniTestb186.sk │ ├── miniTestb187.sk │ ├── miniTestb188.sk │ ├── miniTestb189.sk │ ├── miniTestb190.sk │ ├── miniTestb191.sk │ ├── miniTestb192.sk │ ├── miniTestb193.sk │ ├── miniTestb194.sk │ ├── miniTestb195.sk │ ├── miniTestb196.sk │ ├── miniTestb197.sk │ ├── miniTestb198.sk │ ├── miniTestb199.sk │ ├── miniTestb200.sk │ ├── miniTestb201.sk │ ├── miniTestb202.sk │ ├── miniTestb203.sk │ ├── miniTestb204.sk │ ├── miniTestb205.sk │ ├── miniTestb206.sk │ ├── miniTestb207.sk │ ├── miniTestb208.sk │ ├── miniTestb209.sk │ ├── miniTestb210.sk │ ├── miniTestb211.sk │ ├── miniTestb212.sk │ ├── miniTestb213.sk │ ├── miniTestb214.sk │ ├── miniTestb215.sk │ ├── miniTestb216.sk │ ├── miniTestb217.sk │ ├── miniTestb218.sk │ ├── miniTestb219.sk │ ├── miniTestb220.sk │ ├── miniTestb220_harnesses.sk │ ├── miniTestb221.sk │ ├── miniTestb222.sk │ ├── miniTestb223.sk │ ├── miniTestb224.sk │ ├── miniTestb225.sk │ ├── miniTestb226.sk │ ├── miniTestb227.sk │ ├── miniTestb228.sk │ ├── miniTestb229.sk │ ├── miniTestb230.sk │ ├── miniTestb231.sk │ ├── miniTestb232.sk │ ├── miniTestb233.sk │ ├── miniTestb234.sk │ ├── miniTestb235.sk │ ├── miniTestb236.sk │ ├── miniTestb237.sk │ ├── miniTestb238.sk │ ├── miniTestb239.sk │ ├── miniTestb240.sk │ ├── miniTestb241.sk │ ├── miniTestb242.sk │ ├── miniTestb243.sk │ ├── miniTestb244.sk │ ├── miniTestb245.sk │ ├── miniTestb246.sk │ ├── miniTestb247.sk │ ├── miniTestb248.sk │ ├── miniTestb249.sk │ ├── miniTestb250.sk │ ├── miniTestb251.sk │ ├── miniTestb252.sk │ ├── miniTestb253.sk │ ├── miniTestb254.sk │ ├── miniTestb255.sk │ ├── miniTestb256.sk │ ├── miniTestb257.sk │ ├── miniTestb258.sk │ ├── miniTestb259.sk │ ├── miniTestb260.sk │ ├── miniTestb261.sk │ ├── miniTestb262.sk │ ├── miniTestb263.sk │ ├── miniTestb264.sk │ ├── miniTestb265.sk │ ├── miniTestb266.sk │ ├── miniTestb267.sk │ ├── miniTestb268.sk │ ├── miniTestb269.sk │ ├── miniTestb270.sk │ ├── miniTestb271.sk │ ├── miniTestb272.sk │ ├── miniTestb273.sk │ ├── miniTestb274.sk │ ├── miniTestb275.sk │ ├── miniTestb276.sk │ ├── miniTestb277.sk │ ├── miniTestb278.sk │ ├── miniTestb279.sk │ ├── miniTestb280.sk │ ├── miniTestb281.sk │ ├── miniTestb282.sk │ ├── miniTestb283.sk │ ├── miniTestb284.sk │ ├── miniTestb285.sk │ ├── miniTestb286.sk │ ├── miniTestb287.sk │ ├── miniTestb288.sk │ ├── miniTestb289.sk │ ├── miniTestb290.sk │ ├── miniTestb290a.skh │ ├── miniTestb290b.skh │ ├── miniTestb291.sk │ ├── miniTestb292.sk │ ├── miniTestb293.sk │ ├── miniTestb293a.skh │ ├── miniTestb294.sk │ ├── miniTestb294a.skh │ ├── miniTestb295.sk │ ├── miniTestb295a.skh │ ├── miniTestb296.sk │ ├── miniTestb297.sk │ ├── miniTestb298.sk │ ├── miniTestb299.sk │ ├── miniTestb300.sk │ ├── miniTestb301.sk │ ├── miniTestb302.sk │ ├── miniTestb303.sk │ ├── miniTestb304.sk │ ├── miniTestb305.sk │ ├── miniTestb306.sk │ ├── miniTestb306a.skh │ ├── miniTestb307.sk │ ├── miniTestb308.sk │ ├── miniTestb309.sk │ ├── miniTestb310.sk │ ├── miniTestb311.sk │ ├── miniTestb312.sk │ ├── miniTestb313.sk │ ├── miniTestb314.sk │ ├── miniTestb315.sk │ ├── miniTestb316.sk │ ├── miniTestb317.sk │ ├── miniTestb318.sk │ ├── miniTestb319.sk │ ├── miniTestb320.sk │ ├── miniTestb320_hole.sk │ ├── miniTestb321.sk │ ├── miniTestb322.sk │ ├── miniTestb333.sk │ ├── miniTestb334.sk │ ├── miniTestb335.sk │ ├── miniTestb336.sk │ ├── miniTestb337.sk │ ├── miniTestb338.sk │ ├── miniTestb339.sk │ ├── miniTestb340.sk │ ├── miniTestb341.sk │ ├── miniTestb342.sk │ ├── miniTestb343.sk │ ├── miniTestb344.sk │ ├── miniTestb345.sk │ ├── miniTestb346.sk │ ├── miniTestb347.sk │ ├── miniTestb348.sk │ ├── miniTestb349.sk │ ├── miniTestb350.sk │ ├── miniTestb351.sk │ ├── miniTestb352.sk │ ├── miniTestb353.sk │ ├── miniTestb354.sk │ ├── miniTestb355.sk │ ├── miniTestb356.sk │ ├── miniTestb357.sk │ ├── miniTestb358.sk │ ├── miniTestb359.sk │ ├── miniTestb360.sk │ ├── miniTestb361.sk │ ├── miniTestb362.sk │ ├── miniTestb363.sk │ ├── miniTestb363.skh │ ├── miniTestb364.sk │ ├── miniTestb365.sk │ ├── miniTestb366.sk │ ├── miniTestb367.sk │ ├── miniTestb368.sk │ ├── miniTestb369.sk │ ├── miniTestb370.sk │ ├── miniTestb371.sk │ ├── miniTestb372.sk │ ├── miniTestb373.sk │ ├── miniTestb374.sk │ ├── miniTestb375.sk │ ├── miniTestb376.sk │ ├── miniTestb377.sk │ ├── miniTestb378.sk │ ├── miniTestb379.sk │ ├── miniTestb380.sk │ ├── miniTestb381.sk │ ├── miniTestb382.sk │ ├── miniTestb383.sk │ ├── miniTestb384.sk │ ├── miniTestb385.sk │ ├── miniTestb386.sk │ ├── miniTestb387.sk │ ├── miniTestb388.sk │ ├── miniTestb389.sk │ ├── miniTestb390.sk │ ├── miniTestb391.sk │ ├── miniTestb392.sk │ ├── miniTestb393.sk │ ├── miniTestb394.sk │ ├── miniTestb395.sk │ ├── miniTestb396.sk │ ├── miniTestb397.sk │ ├── miniTestb398.in │ ├── miniTestb398.sk │ ├── miniTestb399.sk │ ├── miniTestb400.sk │ ├── miniTestb401.sk │ ├── miniTestb402.sk │ ├── miniTestb403.sk │ ├── miniTestb404.sk │ ├── miniTestb405.sk │ ├── miniTestb406.sk │ ├── miniTestb406.skh │ ├── miniTestb406b.skh │ ├── miniTestb407.sk │ ├── miniTestb408.sk │ ├── miniTestb409.sk │ ├── miniTestb410.sk │ ├── miniTestb411.sk │ ├── miniTestb412.sk │ ├── miniTestb413.sk │ ├── miniTestb414.sk │ ├── miniTestb415.sk │ ├── miniTestb416.sk │ ├── miniTestb416.skh │ ├── miniTestb417.sk │ ├── miniTestb417.skh │ ├── miniTestb418.sk │ ├── miniTestb419.sk │ ├── miniTestb420.sk │ ├── miniTestb421.sk │ ├── miniTestb422.sk │ ├── miniTestb423.sk │ ├── miniTestb424.sk │ ├── miniTestb425.sk │ ├── miniTestb426.sk │ ├── miniTestb427.sk │ ├── miniTestb428.sk │ ├── miniTestb428.skh │ ├── miniTestb429.sk │ ├── miniTestb429a.skh │ ├── miniTestb429b.skh │ ├── miniTestb430.sk │ ├── miniTestb431.sk │ ├── miniTestb432.sk │ ├── miniTestb433.sk │ ├── miniTestb434.sk │ ├── miniTestb435.sk │ ├── miniTestb436.sk │ ├── miniTestb437.sk │ ├── miniTestb437.skh │ ├── miniTestb438.sk │ ├── miniTestb439.sk │ ├── miniTestb440.sk │ ├── miniTestb441.sk │ ├── miniTestb442.sk │ ├── miniTestb443.sk │ ├── miniTestb444.sk │ ├── miniTestb445.sk │ ├── miniTestb446.sk │ ├── miniTestb447.sk │ ├── miniTestb448.sk │ ├── miniTestb449.sk │ ├── miniTestb450.sk │ ├── miniTestb451.sk │ ├── miniTestb452.sk │ ├── miniTestb453.sk │ ├── miniTestb454.sk │ ├── miniTestb455.sk │ ├── miniTestb456.sk │ ├── miniTestb457.sk │ ├── miniTestb458.sk │ ├── miniTestb459.sk │ ├── miniTestb460.sk │ ├── miniTestb461.sk │ ├── miniTestb462.sk │ ├── miniTestb463.sk │ ├── miniTestb464.sk │ ├── miniTestb465.sk │ ├── miniTestb466.sk │ ├── miniTestb467.sk │ ├── miniTestb468.sk │ ├── miniTestb469.sk │ ├── miniTestb470.sk │ ├── miniTestb471.sk │ ├── miniTestb472.sk │ ├── miniTestb473.sk │ ├── miniTestb473.skh │ ├── miniTestb474.sk │ ├── miniTestb475.sk │ ├── miniTestb476.sk │ ├── miniTestb477.sk │ ├── miniTestb478.sk │ ├── miniTestb479.sk │ ├── miniTestb480.sk │ ├── miniTestb481.sk │ ├── miniTestb482.sk │ ├── miniTestb483.sk │ ├── miniTestb484.sk │ ├── miniTestb485.sk │ ├── miniTestb486.sk │ ├── miniTestb487.sk │ ├── miniTestb488.sk │ ├── miniTestb489.sk │ ├── miniTestb490.sk │ ├── miniTestb491.sk │ ├── miniTestb492.sk │ ├── miniTestb493.sk │ ├── miniTestb494.sk │ ├── miniTestb495.sk │ ├── miniTestb496.sk │ ├── miniTestb497.sk │ ├── miniTestb498.sk │ ├── miniTestb499.sk │ ├── miniTestb500.sk │ ├── miniTestb501.sk │ ├── miniTestb502.sk │ ├── miniTestb503.sk │ ├── miniTestb504.sk │ ├── miniTestb505.sk │ ├── miniTestb506.sk │ ├── miniTestb507.sk │ ├── miniTestb508.sk │ ├── miniTestb509.sk │ ├── miniTestb510.sk │ ├── miniTestb511.sk │ ├── miniTestb511.skh │ ├── miniTestb512.sk │ ├── miniTestb513.sk │ ├── miniTestb514.sk │ ├── miniTestb515.sk │ ├── miniTestb516.sk │ ├── miniTestb517.sk │ ├── miniTestb518.sk │ ├── miniTestb519.sk │ ├── miniTestb520.sk │ ├── miniTestb521.sk │ ├── miniTestb522.sk │ ├── miniTestb523.sk │ ├── miniTestb524.sk │ ├── miniTestb525.sk │ ├── miniTestb526.sk │ ├── miniTestb527.sk │ ├── miniTestb528.sk │ ├── miniTestb529.sk │ ├── miniTestb530.sk │ ├── miniTestb531.sk │ ├── miniTestb532.sk │ ├── miniTestb533.sk │ ├── miniTestb534.sk │ ├── miniTestb535.sk │ ├── miniTestb536.sk │ ├── miniTestb537.sk │ ├── miniTestb538.sk │ ├── miniTestb539.sk │ ├── miniTestb539b.skh │ ├── miniTestb539c.skh │ ├── miniTestb540.sk │ ├── miniTestb541.sk │ ├── miniTestb542.sk │ ├── miniTestb543.sk │ ├── miniTestb544.sk │ ├── miniTestb545.sk │ ├── miniTestb546.sk │ ├── miniTestb547.sk │ ├── miniTestb548.sk │ ├── miniTestb549.sk │ ├── miniTestb550.sk │ ├── miniTestb551.sk │ ├── miniTestb552.sk │ ├── miniTestb553.sk │ ├── miniTestb554.sk │ ├── miniTestb555.sk │ ├── miniTestb556.sk │ ├── miniTestb557.in │ ├── miniTestb557.sk │ ├── miniTestb558.sk │ ├── miniTestb559_RemoveFunctionParameters.sk │ ├── miniTestb561_RemoveFunctionParameters.sk │ ├── miniTestb563_RemoveDumbArrays.sk │ ├── miniTestb564_angelic.sk │ ├── miniTestb565_angelic.sk │ ├── miniTestb566.sk │ ├── miniTestb566_angelic.sk │ ├── miniTestb567.sk │ ├── miniTestb567_angelic.sk │ ├── miniTestb568.sk │ ├── miniTestb569.sk │ ├── miniTestb570.sk │ ├── miniTestb571.sk │ ├── miniTestb572.sk │ ├── miniTestb573.sk │ ├── miniTestb574.sk │ ├── miniTestb575.sk │ ├── miniTestb576.sk │ ├── miniTestb577.sk │ ├── miniTestb578.sk │ ├── miniTestb579.sk │ ├── miniTestb580.sk │ ├── miniTestb581.sk │ ├── miniTestb582.sk │ ├── miniTestb583.sk │ ├── miniTestb584.sk │ ├── miniTestb585.sk │ ├── miniTestb586_adt.sk │ ├── miniTestb587_adt.sk │ ├── miniTestb588_adt.sk │ ├── miniTestb589_adt.sk │ ├── miniTestb590_adt.sk │ ├── miniTestb591_adt.sk │ ├── miniTestb592_adt.sk │ ├── miniTestb593_adt.sk │ ├── miniTestb594_adt.sk │ ├── miniTestb595_adt.sk │ ├── miniTestb596_adt.sk │ ├── miniTestb597_adt.sk │ ├── miniTestb598_adt.sk │ ├── miniTestb599_adt.sk │ ├── miniTestb600_adt.sk │ ├── miniTestb601_adt.sk │ ├── miniTestb602_adt.sk │ ├── miniTestb603.sk │ ├── miniTestb604_adt.sk │ ├── miniTestb605_adt.sk │ ├── miniTestb605a_adt.skh │ ├── miniTestb606.sk │ ├── miniTestb607_adt.sk │ ├── miniTestb608_adt.sk │ ├── miniTestb609_adt.sk │ ├── miniTestb610.sk │ ├── miniTestb611.sk │ ├── miniTestb612.sk │ ├── miniTestb613.sk │ ├── miniTestb614.sk │ ├── miniTestb615.sk │ ├── miniTestb616.sk │ ├── miniTestb617.sk │ ├── miniTestb618.sk │ ├── miniTestb619.sk │ ├── miniTestb620.sk │ ├── miniTestb621.sk │ ├── miniTestb622.sk │ ├── miniTestb623.sk │ ├── miniTestb624.sk │ ├── miniTestb625.sk │ ├── miniTestb626.sk │ ├── miniTestb627.sk │ ├── miniTestb628.sk │ ├── miniTestb629.sk │ ├── miniTestb630.sk │ ├── miniTestb631.sk │ ├── miniTestb632.sk │ ├── miniTestb633.sk │ ├── miniTestb634.sk │ ├── miniTestb635.sk │ ├── miniTestb636.sk │ ├── miniTestb637.sk │ ├── miniTestb638.sk │ ├── miniTestb639.sk │ ├── miniTestb640.sk │ ├── miniTestb641.sk │ ├── miniTestb642.sk │ ├── miniTestb643.sk │ ├── miniTestb644.sk │ ├── miniTestb645.sk │ ├── miniTestb646.sk │ ├── miniTestb647.sk │ ├── miniTestb648.sk │ ├── miniTestb649.sk │ ├── miniTestb650.sk │ ├── miniTestb651.sk │ ├── miniTestb652.sk │ ├── miniTestb653.sk │ ├── miniTestb654.sk │ ├── miniTestb655.sk │ ├── miniTestb656.sk │ ├── miniTestb657.sk │ ├── miniTestb658.sk │ ├── miniTestb659.sk │ ├── miniTestb660.sk │ ├── miniTestb661.sk │ ├── miniTestb662.sk │ ├── miniTestb663.sk │ ├── miniTestb664.sk │ ├── miniTestb666_adt.sk │ ├── miniTestb667_adt.sk │ ├── miniTestb668.sk │ ├── miniTestb669.sk │ ├── miniTestb670.sk │ ├── miniTestb671.sk │ ├── miniTestb672.sk │ ├── miniTestb673.sk │ ├── miniTestb674.sk │ ├── miniTestb675.sk │ ├── miniTestb676.sk │ ├── miniTestb677.sk │ ├── miniTestb678.sk │ ├── miniTestb679.sk │ ├── miniTestb680.sk │ ├── miniTestb681.sk │ ├── miniTestb682.sk │ ├── miniTestb683.sk │ ├── miniTestb684.sk │ ├── miniTestb685.sk │ ├── miniTestb686.sk │ ├── miniTestb687.sk │ ├── miniTestb688.sk │ ├── miniTestb689.sk │ ├── miniTestb690.sk │ ├── miniTestb691.sk │ ├── miniTestb692.sk │ ├── miniTestb693.sk │ ├── miniTestb694.sk │ ├── miniTestb695.sk │ ├── miniTestb696.sk │ ├── miniTestb697.sk │ ├── miniTestb698.sk │ ├── miniTestb699.sk │ ├── miniTestb700.sk │ ├── miniTestb701.sk │ ├── miniTestb702.sk │ ├── miniTestb703.sk │ ├── miniTestb704.sk │ ├── miniTestb705.sk │ ├── miniTestb706.sk │ ├── miniTestb707.sk │ ├── miniTestb708.sk │ ├── miniTestb709.sk │ ├── miniTestb710.sk │ ├── miniTestb711.sk │ ├── miniTestb712.sk │ ├── miniTestb713.sk │ ├── miniTestb714.sk │ ├── miniTestb715.sk │ ├── miniTestb716.sk │ ├── miniTestb717.sk │ ├── miniTestb718.sk │ ├── miniTestb719.sk │ ├── miniTestb720.sk │ ├── miniTestb721.sk │ ├── miniTestb722.sk │ ├── miniTestb723.sk │ ├── miniTestb724.sk │ ├── miniTestb725.sk │ ├── miniTestb726.sk │ ├── miniTestb727.sk │ ├── miniTestb728.sk │ ├── miniTestb729.sk │ ├── miniTestb730.sk │ ├── miniTestb731.sk │ ├── miniTestb732.sk │ ├── miniTestb733.sk │ ├── miniTestb734.sk │ ├── miniTestb735.sk │ ├── miniTestb736.sk │ ├── miniTestb736b.sk │ ├── miniTestb737.sk │ ├── miniTestb738.sk │ ├── miniTestb739.sk │ ├── miniTestb740.sk │ ├── miniTestb741.sk │ ├── miniTestb742.sk │ ├── miniTestb743.sk │ ├── miniTestb744.sk │ ├── miniTestb745.sk │ ├── miniTestb746.sk │ ├── miniTestb747.sk │ ├── miniTestb748.sk │ ├── miniTestb749.sk │ ├── miniTestb750.sk │ ├── miniTestb751.sk │ ├── miniTestb752.sk │ ├── miniTestb753.sk │ ├── miniTestb754.sk │ ├── miniTestb755.sk │ ├── miniTestb756.sk │ ├── miniTestb757.sk │ ├── miniTestb758.sk │ ├── miniTestb759.sk │ ├── miniTestb760.sk │ ├── miniTestb761.sk │ ├── miniTestb762.sk │ ├── miniTestb763.sk │ ├── miniTestb764.sk │ ├── miniTestb765.sk │ ├── miniTestb766.sk │ ├── miniTestb767.sk │ ├── miniTestb768.sk │ ├── miniTestb769.sk │ ├── miniTestb770.sk │ ├── miniTestb771.sk │ ├── miniTestb772.sk │ ├── miniTestb773.sk │ ├── miniTestb774.sk │ ├── miniTestb775.sk │ ├── miniTestb776.sk │ ├── miniTestb777.sk │ ├── miniTestb778.sk │ ├── miniTestb779.sk │ ├── miniTestb780.sk │ ├── miniTestb781.sk │ ├── miniTestb782.sk │ ├── miniTestb783.sk │ ├── miniTestb784.sk │ ├── miniTestb785.sk │ ├── miniTestb786.sk │ ├── miniTestb787.sk │ ├── miniTestb788.sk │ ├── miniTestb789.sk │ ├── miniTestb790.sk │ ├── miniTestb791.sk │ ├── miniTestb792.sk │ ├── miniTestb793.sk │ ├── miniTestb794.sk │ ├── miniTestb795.sk │ ├── miniTestb796.sk │ ├── miniTestb797.sk │ ├── miniTestb798.sk │ ├── miniTestb799.sk │ ├── miniTestb800.sk │ ├── miniTestb801.sk │ ├── miniTestb802.sk │ ├── miniTestb803.sk │ ├── miniTestb804.sk │ ├── miniTestb805.sk │ ├── miniTestb806.sk │ ├── miniTestb807.sk │ ├── miniTestb808.sk │ ├── miniTestb809.sk │ ├── miniTestb810.sk │ ├── miniTestb811.sk │ ├── miniTestb812.sk │ ├── miniTestb813.sk │ ├── miniTestb814.sk │ ├── miniTestb815.sk │ ├── miniTestb816.sk │ ├── miniTestb817.sk │ ├── miniTestb818.sk │ ├── miniTestb819.sk │ ├── miniTestb820.sk │ ├── miniTestb821B.sk │ ├── miniTestb822.sk │ ├── miniTestb823.sk │ ├── miniTestb824.sk │ ├── miniTestb825.sk │ ├── miniTestb826.sk │ ├── miniTestb827.sk │ ├── miniTestb828.sk │ ├── miniTestb829.sk │ ├── miniTestb830.sk │ ├── miniTestb831.sk │ ├── miniTestb832.sk │ ├── miniTestb833.sk │ ├── miniTestb834.sk │ ├── miniTestb835.sk │ ├── miniTestb836.sk │ ├── miniTestb837.sk │ ├── miniTestb838.sk │ ├── miniTestb839.sk │ ├── miniTestb840.sk │ ├── miniTestb841.sk │ ├── miniTestb842.sk │ ├── miniTestb843.sk │ ├── miniTestb844.sk │ ├── miniTestb845.sk │ ├── miniTestb846.sk │ ├── miniTestb847.sk │ ├── miniTestb848.sk │ ├── miniTestb849.sk │ ├── miniTestb850.sk │ ├── miniTestb851.sk │ ├── miniTestb852.sk │ ├── miniTestb853.sk │ ├── miniTestb854.sk │ ├── miniTestb855.sk │ ├── miniTestb856.sk │ ├── miniTestb857.sk │ ├── miniTestb858.sk │ ├── miniTestb859.sk │ ├── miniTestb860.sk │ ├── miniTestb861.sk │ ├── miniTestb862.sk │ ├── miniTestb863.sk │ ├── miniTestb864.sk │ ├── miniTestb865.sk │ ├── miniTestb866.sk │ ├── miniTestb867.sk │ ├── miniTestb868.sk │ ├── miniTestb869.sk │ ├── miniTestb870.sk │ ├── miniTestb871.sk │ ├── miniTestb872.sk │ ├── miniTestb873.sk │ ├── miniTestb874.sk │ ├── miniTestb875.sk │ ├── miniTestb876.sk │ ├── miniTestb877.sk │ ├── miniTestb878.sk │ ├── miniTestb879.sk │ ├── miniTestb880.sk │ ├── miniTestb881.sk │ ├── miniTestb882.sk │ ├── miniTestb883.sk │ ├── miniTestb884.sk │ ├── miniTestb885.sk │ ├── miniTestb886.sk │ ├── miniTestb887.sk │ ├── miniTestb888.sk │ ├── miniTestb889.sk │ ├── miniTestb890.sk │ ├── miniTestb891.sk │ ├── miniTestb892.sk │ ├── miniTestb893.sk │ ├── miniTestb894.sk │ ├── miniTestb895.sk │ ├── miniTestb896.data │ ├── miniTestb896.sk │ ├── miniTestb897.data │ ├── miniTestb897.sk │ ├── miniTestb898.sk │ ├── miniTestb899.sk │ ├── miniTestb900.sk │ ├── miniTestb901.data │ ├── miniTestb901.sk │ ├── miniTestb902.sk │ ├── miniTestb903.sk │ ├── miniTestb904.sk │ ├── miniTestb905.sk │ ├── miniTestb906.sk │ ├── miniTestb908.sk │ ├── miniTestb908_p1.skh │ ├── miniTestb908_p2.skh │ ├── miniTestb909.sk │ └── minitestb821.sk │ └── typechecking │ ├── Makefile │ ├── customDiff.py │ ├── inclusiveOr.sk │ ├── instrs.sk │ ├── typeTest01.sk │ ├── typeTest02.sk │ ├── typeTest03.sk │ ├── typeTest04.sk │ ├── typeTest05.sk │ ├── typeTest06.sk │ ├── typeTest07.sk │ ├── typeTest08.sk │ ├── typeTest09.sk │ ├── typeTest10.sk │ ├── typeTest101.sk │ ├── typeTest11.sk │ ├── typeTest12.sk │ ├── typeTest13.sk │ ├── typeTest14.sk │ ├── typeTest15.sk │ ├── typeTest16.sk │ ├── typeTest17.sk │ ├── typeTest18.sk │ ├── typeTest19.sk │ ├── typeTest20.sk │ ├── typeTest21.sk │ ├── typeTest22.sk │ ├── typeTest23.sk │ ├── typeTest24.sk │ ├── typeTest25.sk │ ├── typeTest26.sk │ ├── typeTest27.sk │ ├── typeTest28.sk │ ├── typeTest29.sk │ ├── typeTest30.sk │ ├── typeTest31.sk │ ├── typeTest31a.skh │ ├── typeTest32.sk │ ├── typeTest33.sk │ ├── typeTest34.sk │ ├── typeTest34.skh │ ├── typeTest35.sk │ ├── typeTest36.sk │ ├── typeTest37.sk │ ├── typeTest38.sk │ ├── typeTest39.sk │ ├── typeTest40.sk │ ├── typeTest41.sk │ ├── typeTest42.sk │ ├── typeTest43.sk │ ├── typeTest44.sk │ ├── typeTest45.sk │ ├── typeTest46.sk │ ├── typeTest47.sk │ ├── typeTest48.sk │ ├── typeTest49.sk │ ├── typeTest50.sk │ ├── typeTest51.sk │ ├── typeTest52.sk │ ├── typeTest53.sk │ ├── typeTest54.sk │ ├── typeTest55.sk │ ├── typeTest56.sk │ ├── typeTest57.sk │ ├── typeTest58.sk │ ├── typeTest59.sk │ ├── typeTest60.sk │ ├── typeTest61.sk │ ├── typeTest62.sk │ ├── typeTest63.sk │ ├── typeTest64.sk │ ├── typeTest65.sk │ ├── typeTest66.sk │ ├── typeTest67.sk │ ├── typeTest68.sk │ ├── typeTest69.sk │ ├── typeTest70.sk │ ├── typeTest71.sk │ ├── typeTest72.sk │ ├── typeTest73.sk │ ├── typeTest74.sk │ ├── typeTest75.sk │ ├── typeTest76.sk │ ├── typeTest77.sk │ ├── typeTest78.sk │ ├── typeTest79.sk │ ├── typeTest80.sk │ ├── typeTest81.sk │ ├── typeTest82.sk │ ├── typeTest83.sk │ ├── typeTest84.sk │ ├── typeTest85.sk │ ├── typeTest86.sk │ ├── typeTest87.sk │ ├── typeTest88.sk │ ├── typeTest89.sk │ ├── typeTest90.sk │ ├── typeTest91.sk │ ├── typeTest92.sk │ ├── typeTest93.sk │ ├── typeTest94.sk │ ├── typeTest95.sk │ ├── typeTest96.sk │ ├── typeTest97.sk │ ├── typeTest98.sk │ ├── typeTestb100.sk │ ├── typeTestb101.sk │ ├── typeTestb102.sk │ ├── typeTestb103.sk │ ├── typeTestb104.sk │ ├── typeTestb105.sk │ ├── typeTestb106.sk │ ├── typeTestb107.sk │ ├── typeTestb108.sk │ ├── typeTestb109.sk │ ├── typeTestb110.sk │ ├── typeTestb111.sk │ ├── typeTestb112.sk │ ├── typeTestb113.sk │ ├── typeTestb114.sk │ ├── typeTestb115.sk │ ├── typeTestb116.sk │ ├── typeTestb117.sk │ ├── typeTestb118.sk │ ├── typeTestb119.sk │ ├── typeTestb120.sk │ ├── typeTestb121.sk │ ├── typeTestb122.sk │ ├── typeTestb123.sk │ ├── typeTestb124.sk │ ├── typeTestb125.sk │ ├── typeTestb126.sk │ ├── typeTestb127.sk │ ├── typeTestb128.sk │ ├── typeTestb129.sk │ ├── typeTestb130.sk │ ├── typeTestb131.sk │ ├── typeTestb132.sk │ ├── typeTestb133.sk │ ├── typeTestb134.sk │ ├── typeTestb135.sk │ ├── typeTestb136.sk │ ├── typeTestb137.sk │ ├── typeTestb138.sk │ ├── typeTestb139.sk │ └── typeTestb140.sk └── testrunner.mk /.gitignore: -------------------------------------------------------------------------------- 1 | src/test/sk/seq/*.output 2 | src/test/sk/seq/*.h 3 | src/test/sk/seq/*.cpp 4 | src/test/sk/seq/ref 5 | src/test/sk/seq/result 6 | src/experiments/RNA 7 | target 8 | tmp-assembly.xml 9 | -------------------------------------------------------------------------------- /.settings/org.eclipse.core.resources.prefs: -------------------------------------------------------------------------------- 1 | eclipse.preferences.version=1 2 | encoding//scripts/code_standards/path_resolv.py=utf-8 3 | encoding//scripts/rewrite_fcns.py=utf-8 4 | -------------------------------------------------------------------------------- /.settings/org.eclipse.core.runtime.prefs: -------------------------------------------------------------------------------- 1 | #Fri Aug 07 19:28:42 PDT 2009 2 | eclipse.preferences.version=1 3 | line.separator=\n 4 | -------------------------------------------------------------------------------- /.settings/org.eclipse.m2e.core.prefs: -------------------------------------------------------------------------------- 1 | #Fri Mar 25 17:45:43 EDT 2011 2 | activeProfiles= 3 | eclipse.preferences.version=1 4 | resolveWorkspaceProjects=true 5 | version=1 6 | -------------------------------------------------------------------------------- /AUTHORS: -------------------------------------------------------------------------------- 1 | Armando Solar-Lezama 2 | Liviu Tancau 3 | Gilad Arnold 4 | Chris Jones 5 | 6 | And the MIT StreamIt team 7 | -------------------------------------------------------------------------------- /ChangeLog: -------------------------------------------------------------------------------- 1 | TODO 2 | -------------------------------------------------------------------------------- /NEWS: -------------------------------------------------------------------------------- 1 | TODO 2 | -------------------------------------------------------------------------------- /benchmarks/testAssume.sk: -------------------------------------------------------------------------------- 1 | pragma options "-V10"; 2 | int f(int n) { 3 | assume n==15; 4 | return n*n; 5 | } 6 | 7 | int g(int n) implements f { 8 | return n*??; 9 | } -------------------------------------------------------------------------------- /benchmarks/transpose/fortran/mpinpb.h: -------------------------------------------------------------------------------- 1 | include 'mpif.h' 2 | c mpi data types 3 | integer dc_type 4 | common /mpistuff/ dc_type 5 | -------------------------------------------------------------------------------- /benchmarks/transpose/run/compile: -------------------------------------------------------------------------------- 1 | module swap PrgEnv-pgi PrgEnv-gnu 2 | CC -O3 -ffast-math -funroll-loops -ftree-vectorizer-verbose=0 -o transpose.x -I ~/runtime/include transpose.cpp 3 | -------------------------------------------------------------------------------- /benchmarks/transpose/run/testdouble.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | double x = double(2048)*2048*2048; 7 | long long y = round(x); 8 | cout << x << ' ' << y << endl; 9 | return 0; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /distconfig/linux_rpm/debian.changelog.jinja2: -------------------------------------------------------------------------------- 1 | {%- import "jinja2_macros.txt" as macros with context -%} 2 | {{ name }} ({{ version }}-{{ release_number }}) stable; urgency=low 3 | 4 | * blank log 5 | 6 | -- {{ macros.maintainer }} Sat, 16 Jan 2010 17:53:18 -0800 7 | -------------------------------------------------------------------------------- /distconfig/linux_rpm/release_number: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /docs/SketchManual/manual.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/docs/SketchManual/manual.pdf -------------------------------------------------------------------------------- /docs/SketchManual/stdlib.tex: -------------------------------------------------------------------------------- 1 | \newpage 2 | \section{Standard Library} 3 | 4 | \input{math.tex} 5 | \newpage 6 | \input{generics.tex} 7 | \newpage 8 | \input{generators.tex} 9 | \newpage 10 | \input{array.tex} 11 | \newpage 12 | \input{list.tex} 13 | \newpage 14 | \input{stack.tex} 15 | -------------------------------------------------------------------------------- /mpidiff: -------------------------------------------------------------------------------- 1 | mpimerge $1 | diff - $2 2 | -------------------------------------------------------------------------------- /mpimerge: -------------------------------------------------------------------------------- 1 | h=1 2 | if [ $# -ge 2 ] 3 | then 4 | h=$2 5 | fi 6 | t=$h 7 | if [ $# -ge 3 ] 8 | then 9 | t=$3 10 | fi 11 | #echo h=$h t=$t 12 | for x in $(ls "$1"?); do sed -e "1,$h d" $x | sed -e :a -e "\$d;N;2,$t ba" -e 'P;D'; done 13 | -------------------------------------------------------------------------------- /pldi/tests/testClosure.sk: -------------------------------------------------------------------------------- 1 | void h(int x, ref int y) { 2 | y = x*??; 3 | } 4 | 5 | harness void main(int input) { 6 | int N = input; 7 | int M = 0; 8 | void g() { 9 | h(input, M); 10 | } 11 | void f() { 12 | N = N+N; 13 | g(); 14 | } 15 | f(); 16 | assert N == M; 17 | } -------------------------------------------------------------------------------- /scripts/unix/install: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | install -m 755 sketch /usr/bin 4 | install -m 755 stensk /usr/bin 5 | install -m 644 sketch-${version}-all-${osname}-${osarch}.jar /usr/bin 6 | -------------------------------------------------------------------------------- /scripts/unix/psketch.jinja2: -------------------------------------------------------------------------------- 1 | {% import "jinja2_macros.txt" as macros %} 2 | {{ macros.sketch_script("par.ParallelSketchMain") }} 3 | -------------------------------------------------------------------------------- /scripts/unix/sketch.jinja2: -------------------------------------------------------------------------------- 1 | {% import "jinja2_macros.txt" as macros %} 2 | {{ macros.sketch_script("seq.SequentialSketchMain") }} 3 | -------------------------------------------------------------------------------- /scripts/unix/stensk.jinja2: -------------------------------------------------------------------------------- 1 | {% import "jinja2_macros.txt" as macros %} 2 | {{ macros.sketch_script("sten.StencilSketchMain") }} 3 | -------------------------------------------------------------------------------- /scripts/vim/ftdetect/sketch.vim: -------------------------------------------------------------------------------- 1 | au BufRead,BufNewFile *.sk,*.sk.jinja2,*.skh,*.skh.jinja2 set filetype=sketch 2 | -------------------------------------------------------------------------------- /scripts/windows/final/installer/Plugins/GetVersion.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/scripts/windows/final/installer/Plugins/GetVersion.dll -------------------------------------------------------------------------------- /scripts/windows/final/installer/Plugins/README: -------------------------------------------------------------------------------- 1 | Copy these files to C:\Program Files (x86)\NSIS\Plugins 2 | -------------------------------------------------------------------------------- /scripts/windows/final/installer/Plugins/UAC.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/scripts/windows/final/installer/Plugins/UAC.dll -------------------------------------------------------------------------------- /scripts/windows/final/installer/Plugins/textreplace.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/scripts/windows/final/installer/Plugins/textreplace.dll -------------------------------------------------------------------------------- /scripts/windows/final/installer/sketch: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | skbat="$(cygpath --windows "$(readlink -f "$(dirname "$0")")/sketch.bat")" 3 | cmd /c "$skbat" "$@" 4 | -------------------------------------------------------------------------------- /scripts/windows/final/installer/sketch.bat: -------------------------------------------------------------------------------- 1 | @java.exe -classpath "%~dp0sketch-${version}-all-${osname}-${osarch}.jar" sketch.compiler.main.seq.SequentialSketchMain %* 2 | -------------------------------------------------------------------------------- /scripts/windows/psketch.jinja2: -------------------------------------------------------------------------------- 1 | {% import "jinja2_macros.txt" as macros %} 2 | {{ macros.sketch_script("par.ParallelSketchMain") }} 3 | -------------------------------------------------------------------------------- /scripts/windows/sketch.jinja2: -------------------------------------------------------------------------------- 1 | {% import "jinja2_macros.txt" as macros %} 2 | {{ macros.sketch_script("seq.SequentialSketchMain") }} 3 | -------------------------------------------------------------------------------- /scripts/windows/stensk.jinja2: -------------------------------------------------------------------------------- 1 | {% import "jinja2_macros.txt" as macros %} 2 | {{ macros.sketch_script("sten.StencilSketchMain") }} 3 | -------------------------------------------------------------------------------- /spmd/doc/mpisketch.pptx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/spmd/doc/mpisketch.pptx -------------------------------------------------------------------------------- /spmd/miniTest_codegen2.sk: -------------------------------------------------------------------------------- 1 | void _nop() { 2 | 3 | } 4 | 5 | int f(int x) { 6 | if (x>0) { 7 | return x+x; 8 | } else { 9 | _nop(); 10 | } 11 | } 12 | 13 | int g(int x) implements f { 14 | if (x>0) { 15 | return x*??; 16 | } else { 17 | _nop(); 18 | } 19 | } -------------------------------------------------------------------------------- /spmd/testBarrier.sk: -------------------------------------------------------------------------------- 1 | harness void main() { 2 | int n = 0; 3 | spmdfork(p; 5) { 4 | n = n+1; 5 | spmdbarrier(); 6 | assert(n == 5); 7 | spmdbarrier(); 8 | n = n+2; 9 | } 10 | assert(n==15); 11 | } 12 | -------------------------------------------------------------------------------- /spmd/testFork.sk: -------------------------------------------------------------------------------- 1 | harness void main() { 2 | int n = 0; 3 | spmdfork(p; 5) { 4 | n = n+1; 5 | } 6 | assert(n==5); 7 | } 8 | -------------------------------------------------------------------------------- /spmd/testLocal.sk: -------------------------------------------------------------------------------- 1 | harness void main() { 2 | int n = 0; 3 | spmdfork(p; 5) { 4 | int i = spmdpid*2; 5 | n = n+spmdpid; 6 | spmdbarrier(); 7 | assert(n == 10); 8 | spmdbarrier(); 9 | n = n-i; 10 | } 11 | assert(n==-10); 12 | } 13 | -------------------------------------------------------------------------------- /spmd/testOutParam.sk: -------------------------------------------------------------------------------- 1 | void transfer(int [2] src, ref int [2] dst) 2 | { 3 | dst = src; 4 | } 5 | 6 | harness void main() 7 | { 8 | int[4] a = {0, 1, 2, 3}; 9 | transfer(a[0::2], a[2::2]); 10 | assert(a[2] == 0); 11 | } 12 | 13 | -------------------------------------------------------------------------------- /spmd/testPid.sk: -------------------------------------------------------------------------------- 1 | harness void main() { 2 | int n = 0; 3 | spmdfork(p; 5) { 4 | n = n+spmdpid; 5 | spmdbarrier(); 6 | assert(n == 10); 7 | spmdbarrier(); 8 | n = n-spmdpid; 9 | } 10 | assert(n==0); 11 | } 12 | -------------------------------------------------------------------------------- /src/experiments/Kliment/constraints.data: -------------------------------------------------------------------------------- 1 | 12 {12.0,11.1,11.32,40.0,8.0,265.0,0.85,10.0,0.2,1.19,0.2,7.03} 1 2 | 12 {16.76,14.8,10.92,21.0,30.0,478.4,0.29,9.99,0.2,1.19,0.21,26.84} 0 3 | -------------------------------------------------------------------------------- /src/experiments/Pankaj/constraints01.txt: -------------------------------------------------------------------------------- 1 | 0.4 0.16 2 | 4.0 2.0 -------------------------------------------------------------------------------- /src/experiments/sk/models/expo_model.skh: -------------------------------------------------------------------------------- 1 | 2 | 3 | int[n] expuf(int x1, int x2); 4 | 5 | 6 | model int[n] mexp(int x1, int x2){ 7 | int[n] rv = expuf(x1,x2); 8 | return rv; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /src/experiments/sk/models/expo_model_old_cegis.skh: -------------------------------------------------------------------------------- 1 | 2 | 3 | int[n] expuf(int x1, int x2); 4 | 5 | 6 | int[n] mexp(int x1, int x2){ 7 | int[n] rv = expuf(x1,x2); 8 | return rv; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/activitysched_sortindex/options.skh: -------------------------------------------------------------------------------- 1 | 2 | int N = 3; 3 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/binarysearch_sort/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inline-amnt 5 --bnd-inbits 3 --bnd-cbits 3 --bnd-unroll-amnt 8"; 2 | int N =5; 3 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/closest_power_two_ilog/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inbits 4 --bnd-inline-amnt 2 --bnd-unroll-amnt 16 --bnd-cbits 3 "; 2 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/closestpair_sortfull/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inline-amnt 5 --bnd-inbits 3 --bnd-cbits 3 --bnd-unroll-amnt 8"; 2 | int N =5; 3 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/gcd_n_numbers/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inbits 4 --bnd-unroll-amnt 14 --bnd-cbits 3 "; 2 | int N = 7; 3 | 4 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/lcm_add_rationals/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inbits 3 --bnd-unroll-amnt 64 --bnd-cbits 3 "; 2 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/lcm_n_numbers/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inbits 3 --bnd-unroll-amnt 8 --bnd-cbits 3 "; 2 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/matexpo_matmult/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inbits 3 --bnd-unroll-amnt 8 --bnd-cbits 3 "; 2 | int n =2; 3 | int gk =3; 4 | int BASE = 5; 5 | struct mat{ 6 | int[n][n] R; 7 | int k; 8 | } 9 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/multiproc-arraysmooth_partition/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inline-amnt 5 --bnd-inbits 4 --bnd-unroll-amnt 32 --bnd-cbits 3 "; 2 | int P = 3; 3 | int N = 24; 4 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/polyderiv_mult/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inline-amnt 16 --bnd-inbits 2 --bnd-cbits 2 --bnd-unroll-amnt 16"; 2 | int n = 20; 3 | int k = 3; 4 | //max degree of polynomials 5 | int BASE = 4; 6 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/polyeval_mult_expo/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inline-amnt 5 --bnd-inbits 2 --bnd-cbits 2 --bnd-unroll-amnt 8"; 2 | int n = 5; 3 | int BASE = 4; 4 | int k=3; 5 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/powerroot_sqrt/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inbits 5 --bnd-unroll-amnt 5 --bnd-cbits 3 "; 2 | int K=2; 3 | -------------------------------------------------------------------------------- /src/experiments/sk/models/model_usage/primality_sqrt/options.skh: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inbits 3 --bnd-unroll-amnt 8 --bnd-cbits 3 "; 2 | -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/activitysched_sortindex/options.skh: -------------------------------------------------------------------------------- 1 | 2 | int N = 4; 3 | -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/binarysearch_sort/options.skh: -------------------------------------------------------------------------------- 1 | 2 | int N =5; 3 | -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/closest_power_two_ilog/options.skh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/models/moresketchified_model_usage/closest_power_two_ilog/options.skh -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/closestpair_sortfull/options.skh: -------------------------------------------------------------------------------- 1 | 2 | int N =5; 3 | -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/gcd_n_numbers/options.skh: -------------------------------------------------------------------------------- 1 | 2 | int N = 5; 3 | 4 | -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/lcm_n_numbers/options.skh: -------------------------------------------------------------------------------- 1 | 2 | int N=5; 3 | -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/matexpo_matmult/options.skh: -------------------------------------------------------------------------------- 1 | 2 | int n =2; 3 | int gk =3; 4 | int BASE = 5; 5 | struct mat{ 6 | int[n][n] R; 7 | int k; 8 | } 9 | -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/multiproc-arraysmooth_partition/options.skh: -------------------------------------------------------------------------------- 1 | 2 | int P = 3; 3 | int N = 5; 4 | -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/polyderiv_mult/options.skh: -------------------------------------------------------------------------------- 1 | 2 | int n = 20; 3 | int k = 3; 4 | //max degree of polynomials 5 | int BASE = 4; 6 | -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/polyeval_mult_expo/options.skh: -------------------------------------------------------------------------------- 1 | 2 | int n = 5; 3 | int BASE = 4; 4 | int k=3; 5 | -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/powerroot_sqrt/options.skh: -------------------------------------------------------------------------------- 1 | 2 | int K=2; 3 | -------------------------------------------------------------------------------- /src/experiments/sk/models/moresketchified_model_usage/primality_sqrt/options.skh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/models/moresketchified_model_usage/primality_sqrt/options.skh -------------------------------------------------------------------------------- /src/experiments/sk/models/scripts/commands_pretty: -------------------------------------------------------------------------------- 1 | for i in `ls ./model_usage/`; do grep $i global_angelic.txt | sed 's/iter=//g' | sed 's/time=//g' | awk 'BEGIN{s1=0;s2=0;} {s0=$1; s1=s1+$2; s2=s2+$3;} END{printf "%s %.2f %.2f\n", s0, s1/5.0, s2/5.0}'; done > pretty_angelic.txt 2 | 3 | 4 | -------------------------------------------------------------------------------- /src/experiments/sk/models/scripts/runmodel.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | #$1 = parameter name of the folder 3 | 4 | -------------------------------------------------------------------------------- /src/experiments/sk/models/sort_model.skh: -------------------------------------------------------------------------------- 1 | 2 | int[N] sortuf(int[N] x); 3 | 4 | model int[N] msort(int[N] x){ 5 | int[N] rv = sortuf(x); 6 | for(int i=0;i= 0 && i < 4); 10 | return tmp[i]; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/bench2/conf/make.sh: -------------------------------------------------------------------------------- 1 | g++ -o runjob runjob.cpp pitimer.cpp 2 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/bench2/conf/postproc.sh: -------------------------------------------------------------------------------- 1 | ./conf/analyzelog $1 2 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/bench2/conf/runajob.sh: -------------------------------------------------------------------------------- 1 | ./runjob `hostname` 2 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/bench2/perf/aestables.h: -------------------------------------------------------------------------------- 1 | extern unsigned int T0[256]; // normalRound.sk:7 2 | extern unsigned int T1[256]; // normalRound.sk:7 3 | extern unsigned int T2[256]; // normalRound.sk:7 4 | extern unsigned int T3[256]; // normalRound.sk:7 5 | 6 | extern void initArrays(); 7 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/bittest1.sk: -------------------------------------------------------------------------------- 1 | int W=128; 2 | 3 | generator bit[W] plusOne(bit[W] in) { /* automatically rewritten */ 4 | in[W-1]=0; 5 | bit[W] one=0; one[0]=1; 6 | int y=1; 7 | one[y:4]=13; 8 | in[1:W-5]=one; 9 | return in;//+one; 10 | } 11 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/errorHandling/miniTest2.sk: -------------------------------------------------------------------------------- 1 | generator bit sp () { return 1; } /* automatically rewritten */ 2 | generator bit sk () { /* automatically rewritten */ 3 | int i = 0; 4 | atomic { 5 | i = i + 1; 6 | } 7 | return 1; 8 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/errorHandling/miniTest4.sk: -------------------------------------------------------------------------------- 1 | generator bit sp () { return 1; } /* automatically rewritten */ 2 | generator bit sk () { /* automatically rewritten */ 3 | fork (int i; 2) { 4 | i = i + 1; 5 | } 6 | return 1; 7 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/flop/sqrt.sk: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/seq/flop/sqrt.sk -------------------------------------------------------------------------------- /src/experiments/sk/seq/gilad/count6-magic.h: -------------------------------------------------------------------------------- 1 | #ifndef COUNT6-MAGIC_H 2 | #define COUNT6-MAGIC_H 3 | 4 | extern void count_sk(unsigned char* a_0, unsigned int& s_1); 5 | extern void count(unsigned char* a_0, unsigned int& s_1); 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/loopTest.sk: -------------------------------------------------------------------------------- 1 | bit debug(bit[4] in) implements loopTest { 2 | bit t=0; 3 | int i=0; 4 | loop({*}){ 5 | i++; 6 | t = in[i]; 7 | } 8 | return t; 9 | } 10 | 11 | bit loopTest(bit[4] in) { 12 | return in[2]; 13 | } 14 | 15 | 16 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/miniTest13.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[5] in) implements reverse { 2 | int i1 = {*}; 3 | int i2 = {*}; 4 | return in[i1+i2]^in[i1]; 5 | } 6 | 7 | 8 | bit reverse (bit[5] in) { 9 | return in[4]^in[3]; 10 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/miniTest15.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[4] in) implements reverse { 2 | bit [2] tmp = ??; 3 | return in[(int)tmp]; 4 | } 5 | 6 | 7 | bit reverse (bit[4] in) { 8 | return in[3]; 9 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/miniTest18.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[4] in) implements reverse { 2 | bit [5] tmp = {*}; 3 | bit [2] tmp2 = {*}; 4 | return in[(int)(tmp>>((int)tmp2))]; 5 | } 6 | 7 | 8 | bit reverse (bit[4] in) { 9 | return in[2]; 10 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/miniTest2.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[4] in) implements reverse { 2 | bit [4] tmp = in; 3 | tmp[2] = 1; 4 | tmp[3] = 0; 5 | return tmp[{*}]; 6 | } 7 | 8 | 9 | bit reverse (bit[4] in) { 10 | return in[1]; 11 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/miniTest5.sk: -------------------------------------------------------------------------------- 1 | generator bit foo(bit[4] in){ /* automatically rewritten */ 2 | return in[{*}]; 3 | } 4 | 5 | bit reverseSketch(bit[4] in) implements reverse { 6 | 7 | return foo(in) ^ foo(in); 8 | } 9 | 10 | bit reverse (bit[4] in) { 11 | return in[2] ^ in[3]; 12 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/perftest/hardGenerator.sk: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/seq/perftest/hardGenerator.sk -------------------------------------------------------------------------------- /src/experiments/sk/seq/perftest/help.sh: -------------------------------------------------------------------------------- 1 | x=$1; 2 | 3 | time bash preproc.sh --incremental 6 --seed 10 ${x} 4 | 5 | 6 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/ras/SKETCH/Sparse/ufun-test1.sk: -------------------------------------------------------------------------------- 1 | bit ONE(int x){ 2 | return 1; 3 | } 4 | 5 | int T = 4; 6 | 7 | generator int f(int x); /* automatically rewritten */ 8 | 9 | bit main(int x) implements ONE{ 10 | assert ??*f(x)==f(x)+f(x); 11 | return 1; 12 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/ras/SKETCH/non-linear.sk: -------------------------------------------------------------------------------- 1 | int main() implements one { 2 | assert ?? * ?? = 99; 3 | return 1; 4 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/ras/SKETCH/test-constant-replacer-on-globals.sk: -------------------------------------------------------------------------------- 1 | int g = 2; 2 | generator void main () { /* automatically rewritten */ 3 | g = 1; 4 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/ras/SKETCH/test-regr-global.sk: -------------------------------------------------------------------------------- 1 | struct S { int field; } 2 | 3 | int g=2; 4 | 5 | void v(int x) {} 6 | 7 | void sparsify(int x) implements v { 8 | S ptr = new S(); 9 | if (g>0) { 10 | g = 1; 11 | x = 1; 12 | ptr.field = 1; 13 | } 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/ras/SKETCH/test-regr-local.sk: -------------------------------------------------------------------------------- 1 | void v(int x) {} 2 | 3 | void sparsify(int x) implements v { 4 | if (x>0) { 5 | x = 1; 6 | } 7 | } 8 | 9 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/ras/SKETCH/test01.sk: -------------------------------------------------------------------------------- 1 | int spec () { return 1; } 2 | 3 | #define assume(e) if (!(e)) return 1; 4 | 5 | int foo() implements spec { 6 | 7 | int t = ??; 8 | 9 | assume(1 == 2); 10 | 11 | assert 1 == t && 2 == t; 12 | 13 | return 1; 14 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/ras/SKETCH/test_structs_with_arrays.sk: -------------------------------------------------------------------------------- 1 | struct S { 2 | int[3] arr; 3 | } 4 | 5 | int main() implements one { 6 | S s = new S(); 7 | int a = s.arr[0]; 8 | return 1; 9 | } 10 | 11 | int one() { return 1; } -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/001.sk: -------------------------------------------------------------------------------- 1 | int spec (int in) { 2 | return in * 2; 3 | } 4 | 5 | int sk (int in) implements spec { 6 | return {| in (+|-|*|/|%) ?? |}; 7 | } 8 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/002.sk: -------------------------------------------------------------------------------- 1 | struct S { 2 | S next; 3 | int i; 4 | } 5 | 6 | int sp () { return 1; } 7 | int sk () implements sp { 8 | S s = new S (); 9 | s.next = new S (); 10 | s.next.i = 1; 11 | return {| s.next.i |}; 12 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/003.sk: -------------------------------------------------------------------------------- 1 | struct S { 2 | S next; 3 | int i; 4 | } 5 | 6 | int sp () { return 0; } 7 | int sk () implements sp { 8 | S a = new S (), b = new S (); 9 | a.i = 1; 10 | b.i = 0; 11 | return {| (a | b)(.next | .prev)?.i |}; 12 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/004.sk: -------------------------------------------------------------------------------- 1 | struct S { 2 | S next; 3 | int i; 4 | } 5 | 6 | generator int sp () { return 0; } /* automatically rewritten */ 7 | generator int sk () { /* automatically rewritten */ 8 | S s = new S (); 9 | return {| 1 (<<|+|*) 2 |}; 10 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/005.sk: -------------------------------------------------------------------------------- 1 | generator int sp (int in) { return 0; } /* automatically rewritten */ 2 | generator int sk (int in) { /* automatically rewritten */ 3 | return {| (~|++)?in |}; 4 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/008.sk: -------------------------------------------------------------------------------- 1 | int sp () { return 0; } 2 | int sk () implements sp { 3 | int x = 0; 4 | return ++{| x | x |}; 5 | } 6 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/009.sk: -------------------------------------------------------------------------------- 1 | int sp (int a, int b, int c, int d) { 2 | return a & b + c * d; 3 | } 4 | int sk (int a, int b, int c, int d) implements sp { 5 | return {| a & b + c * d |}; 6 | } 7 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/010.sk: -------------------------------------------------------------------------------- 1 | int sp (int a, int b, int c, int d) { 2 | return a + b - c + d; 3 | } 4 | int sk (int a, int b, int c, int d) implements sp { 5 | return {| a + b - c + d |}; 6 | } 7 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/011.sk: -------------------------------------------------------------------------------- 1 | int sp (int a, int b, int c, int d, int e) { 2 | return a & b + (c | d) * e; 3 | } 4 | int sk (int a, int b, int c, int d, int e) implements sp { 5 | return {| a & b + (c \| d) * e |}; 6 | } 7 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/err/001.sk: -------------------------------------------------------------------------------- 1 | generator int sp () { return 0; } /* automatically rewritten */ 2 | generator int sk () { /* automatically rewritten */ 3 | return {| 1.foo |}; 4 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/err/002.sk: -------------------------------------------------------------------------------- 1 | struct S { 2 | S next; 3 | int i; 4 | } 5 | 6 | generator int sp () { return 0; } /* automatically rewritten */ 7 | generator int sk () { /* automatically rewritten */ 8 | S s = new S (); 9 | return {| s(.next | .i) |}; 10 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/err/003.sk: -------------------------------------------------------------------------------- 1 | struct S { 2 | S next; 3 | int i; 4 | } 5 | 6 | generator int sp () { return 0; } /* automatically rewritten */ 7 | generator int sk () { /* automatically rewritten */ 8 | S s = new S (); 9 | return {| s(.i)? |}; 10 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/err/004.sk: -------------------------------------------------------------------------------- 1 | struct S { 2 | S next; 3 | int i; 4 | } 5 | 6 | generator int sp () { return 0; } /* automatically rewritten */ 7 | generator int sk () { /* automatically rewritten */ 8 | S s = new S (); 9 | return {| s(.next) |}; 10 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/err/005.sk: -------------------------------------------------------------------------------- 1 | generator int sp () { return 0; } /* automatically rewritten */ 2 | generator int sk () { /* automatically rewritten */ 3 | int x = 0; 4 | {| x|1 |} = 1; 5 | return x; 6 | } 7 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/err/007.sk: -------------------------------------------------------------------------------- 1 | generator int sp () { return 0; } /* automatically rewritten */ 2 | generator int sk () { /* automatically rewritten */ 3 | int x = 0; 4 | return ++{| x | 1 |}; 5 | } 6 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/regens/err/009.sk: -------------------------------------------------------------------------------- 1 | struct S { 2 | S next; 3 | } 4 | 5 | generator int sp () { return 0; } /* automatically rewritten */ 6 | int sk () implements sk { 7 | S s = new S (); 8 | return {| s(.next|.prev)?.i |}; 9 | } -------------------------------------------------------------------------------- /src/experiments/sk/seq/structs/atomic.sk: -------------------------------------------------------------------------------- 1 | bit foo (bit z) { 2 | return z; 3 | } 4 | 5 | bit bar (bit y) implements foo { 6 | bit x = 0; 7 | 8 | reorder { 9 | atomic { 10 | x = x ^ !x; 11 | } 12 | y = y; 13 | } 14 | 15 | return y; 16 | } 17 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/test: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | sketch --outputcode --incremental 6 --seed 10 "$@" 3 | #sketch --outputcode -overrideCtrls 3 -overrideInputs 3 --seed 10 "$@" 4 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/test-debug: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | sketch-debug --outputcode --incremental 6 --seed 10 "$@" 3 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/seq/thesisBenchmarks/.cpp -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/Makefile: -------------------------------------------------------------------------------- 1 | short: 2 | bash ./regtest.sh 3 | short-abc: 4 | bash ./regtest.sh ABC 5 | 6 | long: 7 | bash ./regtest2.sh 8 | clean: 9 | ./clean.sh 10 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/afa_spec: -------------------------------------------------------------------------------- 1 | f00000 2 | c1001001100110000110000000 3 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/appdx.awk: -------------------------------------------------------------------------------- 1 | { 2 | 3 | print "\\C{"$1"} \\\\" 4 | print "\\begin{tabular}{ccccc}" 5 | print $6"& $C_{int}$ ="$2 " & $C_{bit}$ ="$3" & $in_{bits}$ ="$4" & "$5" lines\\\\" 6 | print "\\end{tabular}\\\\\\\\" 7 | 8 | 9 | } 10 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/armando/llreverse.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/seq/thesisBenchmarks/armando/llreverse.exe -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/armando/morton/reduced.sk: -------------------------------------------------------------------------------- 1 | bit[2] spec(bit[1] x) { 2 | return x; 3 | } 4 | 5 | bit[2] sketch(bit[1] x) implements spec { 6 | //bit[2] v = ??; 7 | return x & ??; 8 | } 9 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/clean.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | rm -f script *.h *.exe *.stackdump *.c *.cpp *.cc *.sout *.output *.tmp 3 | for FILE in *.sk; do rm -f ${FILE%.sk}; done 4 | 5 | 6 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/doublyLinkedList.dmcs.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/seq/thesisBenchmarks/doublyLinkedList.dmcs.gz -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/lss_hardest.dmcs.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/seq/thesisBenchmarks/lss_hardest.dmcs.gz -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/parity.dmcs.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/seq/thesisBenchmarks/parity.dmcs.gz -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/polynomial.dmcs.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/seq/thesisBenchmarks/polynomial.dmcs.gz -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/polynomial_inv.dmcs.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/seq/thesisBenchmarks/polynomial_inv.dmcs.gz -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/result3: -------------------------------------------------------------------------------- 1 | SAT -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/runkar.sh: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | for x in `ls harder/k*.sk` 8 | do 9 | 10 | echo "RUNNING " $x 11 | 12 | sketch --timeout 18 --seed $((RANDOM % 20)) --verbosity 10 ${x} | "$FRONTEND"/sbin/dataCollect.sh 13 | 14 | done 15 | 16 | 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/sizeExpers/enqueue_N3.sk: -------------------------------------------------------------------------------- 1 | 2 | int N = 3; 3 | #include "enqueue.skh" 4 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/sizeExpers/enqueue_N4.sk: -------------------------------------------------------------------------------- 1 | 2 | int N = 4; 3 | #include "enqueue.skh" 4 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/sizeExpers/enqueue_N5.sk: -------------------------------------------------------------------------------- 1 | 2 | int N = 5; 3 | #include "enqueue.skh" 4 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/sizeExpers/enqueue_N6.sk: -------------------------------------------------------------------------------- 1 | 2 | int N = 6; 3 | #include "enqueue.skh" 4 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/sizeExpers/reverse_N3.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 4"; 2 | int N = 3; 3 | #include "listReverse.skh" 4 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/sizeExpers/reverse_N4.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 4"; 2 | int N = 4; 3 | #include "listReverse.skh" 4 | 5 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/sizeExpers/reverse_N5.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 4"; 2 | int N = 5; 3 | #include "listReverse.skh" 4 | 5 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/sizeExpers/reverse_N6.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 4"; 2 | int N = 6; 3 | #include "listReverse.skh" 4 | 5 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/sizeExpers/setTest_T4.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 5 --bnd-inbits 3 "; 2 | int T = 4; 3 | #include "SetTest.skh" 4 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/sizeExpers/setTest_T5.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 5 --bnd-inbits 3 "; 2 | int T = 5; 3 | #include "SetTest.skh" 4 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/sizeExpers/setTest_T6.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 5 --bnd-inbits 3 "; 2 | int T = 6; 3 | #include "SetTest.skh" 4 | 5 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/timetable.dat: -------------------------------------------------------------------------------- 1 | polynomial.dmcs,1,7265.940,0.150,6950,1827,0.011841,724752,61205286,777,97954,5 2 | tmp.dmcs,1,865.000,0.310,1000,254,0.010622,73156,6887357,80,11984,7 3 | polynomial.dmcs,1,915.940,0.160,1000,254,0.010622,73156,6887357,80,11984,7 4 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/tmp.dmcs.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/experiments/sk/seq/thesisBenchmarks/tmp.dmcs.gz -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/tmp.sh: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | bash runBenchmarks.sh ABC MINI 5 5 | bash runBenchmarks.sh ABC MINI 5 6 | bash runBenchmarks.sh ABC MINI 5 7 | bash runBenchmarks.sh ABC MINI 5 8 | 9 | 10 | -------------------------------------------------------------------------------- /src/experiments/sk/seq/thesisBenchmarks/tutorial1.sk: -------------------------------------------------------------------------------- 1 | int spec( int x ){ 2 | return x + x; 3 | } 4 | 5 | int sketch( int x ) implements spec{ 6 | return ?? * x; 7 | } -------------------------------------------------------------------------------- /src/main/java/sketch/compiler/solvers/CounterExample.java: -------------------------------------------------------------------------------- 1 | package sketch.compiler.solvers; 2 | 3 | public abstract class CounterExample { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /src/main/java/sketch/util/annot/CodeGenerator.java: -------------------------------------------------------------------------------- 1 | package sketch.util.annot; 2 | 3 | import java.lang.annotation.Retention; 4 | import java.lang.annotation.RetentionPolicy; 5 | 6 | @Retention(RetentionPolicy.RUNTIME) 7 | public @interface CodeGenerator { 8 | 9 | 10 | } 11 | -------------------------------------------------------------------------------- /src/main/java/sketch/util/datastructures/LongHashObject.java: -------------------------------------------------------------------------------- 1 | package sketch.util.datastructures; 2 | 3 | public interface LongHashObject { 4 | long longHash(); 5 | } 6 | -------------------------------------------------------------------------------- /src/main/java/sketch/util/thread/MTSafe.java: -------------------------------------------------------------------------------- 1 | package sketch.util.thread; 2 | 3 | public @interface MTSafe { 4 | } 5 | -------------------------------------------------------------------------------- /src/release_benchmarks/ImProcDemo/cmd: -------------------------------------------------------------------------------- 1 | sketch --fe-inc Img --fe-output-code --fe-kill-asserts edgeDetector.sk 2 | g++ -O3 -I Img/ -I ../../runtime/include/ edgeDetector.cpp driver.cpp 3 | -------------------------------------------------------------------------------- /src/release_benchmarks/ImProcDemo/driver.cpp: -------------------------------------------------------------------------------- 1 | #include "HFILE" 2 | 3 | #include 4 | 5 | int main(int argc, char** argv){ 6 | ANONYMOUS::main__Wrapper(strlen(argv[1])+1, argv[1]); 7 | } 8 | -------------------------------------------------------------------------------- /src/release_benchmarks/ImageProc/driver.cpp: -------------------------------------------------------------------------------- 1 | #include "test1.h" 2 | 3 | int main(int argc, char** argv){ 4 | ANONYMOUS::main__Wrapper(); 5 | } -------------------------------------------------------------------------------- /src/release_benchmarks/ImageProc/driver2.cpp: -------------------------------------------------------------------------------- 1 | #include "test2.h" 2 | 3 | #include 4 | 5 | int main(int argc, char** argv){ 6 | ANONYMOUS::main__Wrapper(strlen(argv[1])+1, argv[1]); 7 | } -------------------------------------------------------------------------------- /src/release_benchmarks/ImageProc/testb.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asolarlez/sketch-frontend/932a91dacdd0016859e90bb7927a35a05a47a798/src/release_benchmarks/ImageProc/testb.bmp -------------------------------------------------------------------------------- /src/release_benchmarks/gallery/tutorial1.sk: -------------------------------------------------------------------------------- 1 | //@Description Toy benchmark. 2 | 3 | int spec( int x ){ 4 | return x + x; 5 | } 6 | 7 | int sketch( int x ) implements spec{ 8 | return ?? * x; 9 | } 10 | -------------------------------------------------------------------------------- /src/release_benchmarks/sk/Makefile: -------------------------------------------------------------------------------- 1 | short: 2 | bash ./regtest.sh 3 | short-abc: 4 | bash ./regtest.sh ABC 5 | 6 | long: 7 | bash ./regtest2.sh 8 | clean: 9 | ./clean.sh 10 | -------------------------------------------------------------------------------- /src/release_benchmarks/sk/clean.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | rm -f script *.h *.exe *.stackdump *.c *.cpp *.cc *.sout *.output *.tmp 3 | for FILE in *.sk; do rm -f ${FILE%.sk}; done 4 | 5 | 6 | -------------------------------------------------------------------------------- /src/release_benchmarks/sk/runkar.sh: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | for x in `ls harder/k*.sk` 8 | do 9 | 10 | echo "RUNNING " $x 11 | 12 | sketch --timeout 18 --seed $((RANDOM % 20)) --verbosity 10 ${x} | "$FRONTEND"/sbin/dataCollect.sh 13 | 14 | done 15 | 16 | 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /src/release_benchmarks/sk/tutorial1.sk: -------------------------------------------------------------------------------- 1 | //@Description Toy benchmark. 2 | 3 | int spec( int x ){ 4 | return x + x; 5 | } 6 | 7 | int sketch( int x ) implements spec{ 8 | return ?? * x; 9 | } 10 | -------------------------------------------------------------------------------- /src/resources/filtered/sketch/compiler/resources/localization.properties: -------------------------------------------------------------------------------- 1 | version = ${version} 2 | osname = ${os.name} 3 | osarch = ${os.arch} 4 | -------------------------------------------------------------------------------- /src/runtime/include/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS=-Wall 2 | OBJECTS=bitvec.o 3 | BINARIES=bvtest 4 | 5 | .PHONY: clean all 6 | 7 | all: $(OBJECTS) $(BINARIES) 8 | 9 | clean: 10 | rm -f $(BINARIES) $(OBJECTS) 11 | 12 | $(OBJECTS):%.o: Makefile 13 | 14 | bvtest: bitvec.h 15 | 16 | -------------------------------------------------------------------------------- /src/runtime/include/isEmpty.h: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "string.h" 3 | #include "stdlib.h" 4 | #include "vops.h" 5 | 6 | namespace fileIO{ 7 | 8 | inline int _isEmpty(FILE* cfile){ 9 | if(feof(cfile)!=0) 10 | return 1; 11 | else 12 | return 0; 13 | } 14 | } -------------------------------------------------------------------------------- /src/sketchlib/intops.skh: -------------------------------------------------------------------------------- 1 | package Int; 2 | 3 | generator int abs(int i){ 4 | return i>=0?i:-i; 5 | } 6 | 7 | generator int max(int i, int j){ 8 | return i>=j?i:j; 9 | } 10 | 11 | generator int min(int i, int j){ 12 | return i>=j?j:i; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/test/deprecated/par/Makefile: -------------------------------------------------------------------------------- 1 | .PHONY: all test-solver test-cgen clean 2 | 3 | all: test-solver 4 | 5 | test-solver: 6 | bash ./regtest.sh 7 | test-cgen: 8 | bash ./regtest2.sh 9 | clean: 10 | ./clean.sh 11 | -------------------------------------------------------------------------------- /src/test/deprecated/par/clean.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | rm -f script *.h *.exe *.stackdump *.c *.cpp *.cc *.sout *.output *.tmp 3 | for FILE in *.sk; do rm -f ${FILE%.sk}; done 4 | 5 | 6 | -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/array.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-cbits 11 --bnd-intbits 11"; 2 | 3 | void main(int dummy) implements one{ 4 | int[50] a; 5 | 6 | a[0] = ??; 7 | a[1] = ??; 8 | assert a[0] == 99; 9 | assert a[1] == 999; 10 | } 11 | void one(int dummy) {} -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/arrayAssignToArray.sk: -------------------------------------------------------------------------------- 1 | 2 | #define N 2 3 | void main(int dummy) implements one{ 4 | int[N] a = ??; 5 | 6 | int[N] b = a; 7 | assert b[0] == 3; 8 | assert b[1] == 4; 9 | } 10 | void one(int dummy) {} -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/arrayInit.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[5] in) implements reverse { 2 | int [4] fu = { 2, 3, 4, 0 }; 3 | 4 | return in[fu[??]]; 5 | } 6 | 7 | 8 | bit reverse (bit[5] in) { 9 | return in[3]; 10 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/arrayOfHoles.sk: -------------------------------------------------------------------------------- 1 | int W=3; 2 | 3 | void main(int dummy) implements one { 4 | int[W*W] S=??; // knuth(level); 5 | assert (S[0] == 30); 6 | 7 | } 8 | 9 | void one(int dummy) { 10 | 11 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/arrayUpdateToHole.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one{ 2 | int[10] a = ??; 3 | 4 | 5 | assert a[5] == 5; 6 | 7 | } 8 | void one(int dummy) {} -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/binaryDivide.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one { 2 | int d = ??; // 6 3 | assert d / 2 == 3; 4 | } 5 | 6 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/binaryDivideZero.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one { 2 | 3 | int d = 6 / ??; // 2 4 | assert d == 3; 5 | } 6 | 7 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/binaryXOR.sk: -------------------------------------------------------------------------------- 1 | bit sketch(bit in) implements one { 2 | 3 | bit[4] x = {1, 0, 1, 0}; 4 | bit[4] t = ??; 5 | assert (x ^ t) == 4; 6 | 7 | return 1; 8 | } 9 | 10 | bit one (bit in) { 11 | return 1; 12 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/boolType.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one { 2 | bool a; 3 | 4 | if (dummy == 30) { 5 | 6 | } else { 7 | a = ??; 8 | assert a == false; 9 | } 10 | 11 | 12 | } 13 | 14 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/bvIf.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one { 2 | 3 | bit[2] a = {1, 1}; 4 | 5 | 6 | if (!??) { 7 | a[0] = 0; 8 | 9 | } else { 10 | a[1] = 0; 11 | } 12 | 13 | assert a[0] != 0; 14 | } 15 | 16 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/concat.sk: -------------------------------------------------------------------------------- 1 | int concatSk(bit[4] in) implements concat { 2 | int a = in[3]; // 3 | return a + ??; 4 | } 5 | 6 | 7 | int concat (bit[4] in) { 8 | return in[3] + 30; 9 | } 10 | -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/convertIntToBitArray.sk: -------------------------------------------------------------------------------- 1 | int main(int dummy) implements one{ 2 | int c = 8; 3 | bit[4] a = (bit[4]) c; // this is turned into {8, 0, 0, 0} 4 | assert a[0] == 0; 5 | return 1; 6 | } 7 | 8 | int one (int dummy) { return 1; } 9 | -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/empty.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one{ 2 | 3 | } 4 | 5 | void one(int dummy) {} -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/extract.sk: -------------------------------------------------------------------------------- 1 | bit extractSk(bit[4] in) implements extract { 2 | bit a; 3 | a = ??; 4 | return in[0] | a; 5 | } 6 | 7 | 8 | bit extract (bit[4] in) { 9 | return 1; 10 | } 11 | -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/ifStmt.sk: -------------------------------------------------------------------------------- 1 | 2 | void main(int dummy) implements one{ 3 | 4 | int a = ??; 5 | 6 | int x; 7 | if (a == 30) { 8 | x = 90; 9 | } else { 10 | x = 100; 11 | } 12 | 13 | assert x == 90; 14 | 15 | } 16 | 17 | void one(int dummy) { 18 | 19 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/integerWhile.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one { 2 | int i = 0; 3 | 4 | while (i < 5) { 5 | i++; 6 | } 7 | 8 | assert i == 10 - ??; 9 | 10 | } 11 | 12 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/integers.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-cbits 7 --bnd-intbits 10"; 2 | void main(int dummy) implements one { 3 | int a; 4 | 5 | a = ??; 6 | assert a == 30; 7 | 8 | a = ??; 9 | assert a == 40; 10 | 11 | } 12 | 13 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/integersIf.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one { 2 | int a; 3 | 4 | if (dummy == 0) { 5 | a = ??; 6 | } else { 7 | a = ??; 8 | } 9 | 10 | assert a == 30; 11 | } 12 | 13 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/integersIf2.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one { 2 | 3 | int a; 4 | 5 | a = {|1|2|}; 6 | 7 | if (??) { 8 | a = a + 1; 9 | } else { 10 | a = a + 2; 11 | } 12 | 13 | assert a == 2; 14 | } 15 | 16 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/lshift.sk: -------------------------------------------------------------------------------- 1 | int W = 5; 2 | void main(bit[W] dummy) implements one { 3 | bit[W] a = {0, 0, 1, 0, 0}; 4 | bit[W] b; 5 | 6 | int c = ??; 7 | 8 | b = a << c; 9 | 10 | 11 | assert (b[4] == 1); 12 | } 13 | 14 | void one(bit[W] dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/negativeInt.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-cbits 11 --bnd-intbits 11"; 2 | 3 | void main(boolean dummy) implements one { 4 | int a = -1; 5 | int h = ??; 6 | 7 | assert a + h == 999; 8 | } 9 | 10 | void one(boolean dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/regexpr.sk: -------------------------------------------------------------------------------- 1 | 2 | void main(int dummy) implements one { 3 | int a; 4 | 5 | a = {|1|2|}; 6 | assert a == 2; 7 | 8 | } 9 | 10 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/regexpr3.sk: -------------------------------------------------------------------------------- 1 | 2 | void main(int dummy) implements one { 3 | int a; 4 | 5 | a = {|1|2|3|}; 6 | assert a == 2; 7 | 8 | } 9 | 10 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/smallWidthHole.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-cbits 2"; 2 | 3 | bit one(int dummy) { 4 | return 1; 5 | } 6 | 7 | bit sketch(int dummy) implements one{ 8 | int x = ??; 9 | if (x == 0) { 10 | assert false; 11 | } 12 | 13 | return 1; 14 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/typecast.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one { 2 | bit a; 3 | 4 | a = (?? == 6) && true; 5 | 6 | assert a == 1; 7 | 8 | } 9 | 10 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/unaryOpsBitNot.sk: -------------------------------------------------------------------------------- 1 | void reverseSketch(int dummy) implements reverse { 2 | 3 | bit c = ??; // 1 4 | bit cc = !c; 5 | assert cc == 0; 6 | 7 | } 8 | 9 | 10 | void reverse (int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/unaryOpsLogicalNot.sk: -------------------------------------------------------------------------------- 1 | void reverseSketch(int dummy) implements reverse { 2 | 3 | boolean b = (boolean) ??; // true 1 4 | boolean bb = !b; 5 | assert !b == false; 6 | 7 | } 8 | 9 | 10 | void reverse (int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/basics/varAssignment.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one { 2 | int a; 3 | a = 1; 4 | a = 2; 5 | a = 3; 6 | a = 4; 7 | assert a == 4; 8 | 9 | } 10 | 11 | void one(int dummy) { } -------------------------------------------------------------------------------- /src/test/deprecated/smt/bitvectors/arrayAssignment.sk: -------------------------------------------------------------------------------- 1 | bit oneSketch(bit[4] in) implements one { 2 | bit[4] a; 3 | a = in; 4 | 5 | return a[3]; 6 | } 7 | 8 | 9 | bit one (bit[4] in) { 10 | return in[3]; 11 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/bitvectors/castBottomScalarToBitArray.sk: -------------------------------------------------------------------------------- 1 | bit[2] reverseSketch(bit[4] in) implements reverse { 2 | bit[2] t = in[1]; 3 | return t; 4 | } 5 | 6 | bit[2] reverse (bit[4] in) { 7 | bit[2] t; 8 | t[0] = in[1]; 9 | t[1] = 0; 10 | return t; 11 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/bitvectors/castConstScalarToBitArray.sk: -------------------------------------------------------------------------------- 1 | bit[2] reverseSketch(bit[4] in) implements reverse { 2 | bit[2] t = 1; 3 | return t; 4 | } 5 | 6 | bit[2] reverse (bit[4] in) { 7 | bit[2] t; 8 | t[0] = 1; 9 | t[1] = 0; 10 | return t; 11 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/bitvectors/elementAccWithBottomIdx.sk: -------------------------------------------------------------------------------- 1 | pragma options "--sem-array-OOB-policy wrsilent_rdzero"; 2 | 3 | bit oneSketch(bit[4] in, int idx) implements one { 4 | return in[idx]; 5 | 6 | } 7 | 8 | 9 | bit one (bit[4] in, int idx) { 10 | 11 | return in[idx]; 12 | 13 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/bitvectors/elementRangeAccWithConstRange.sk: -------------------------------------------------------------------------------- 1 | bit oneSketch(bit[4] in) implements one { 2 | bit[4] a = in; 3 | bit[2] tmp; 4 | 5 | tmp = in[1::2]; 6 | 7 | return tmp[1]; 8 | } 9 | 10 | bit one (bit[4] in) { 11 | return in[2]; 12 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/bitvectors/elementUpdateWithConstIdx.sk: -------------------------------------------------------------------------------- 1 | bit oneSketch(bit[4] in) implements one { 2 | bit[4] a; 3 | 4 | a[3] = in[0]; 5 | 6 | return a[3]; 7 | } 8 | 9 | bit one (bit[4] in) { 10 | return in[0]; 11 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/bitvectors/hole.sk: -------------------------------------------------------------------------------- 1 | bit oneSketch(bit[4] in) implements one { 2 | bit[4] a = ??; 3 | assert a[0] == 1; 4 | // assert a[1] == 0; 5 | // assert a[2] == 0; 6 | // assert a[3] == 1; 7 | // 8 | return 1; 9 | } 10 | 11 | bit one (bit[4] in) { 12 | return 1; 13 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/bitvectors/init.sk: -------------------------------------------------------------------------------- 1 | bit oneSketch(bit[4] in) implements one { 2 | bit[4] a; 3 | a = 1; // a = {1, 0, 0, 0} 4 | return 1; 5 | } 6 | 7 | 8 | bit one (bit[4] in) { 9 | return 1; 10 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/bitvectors/vectorIndex.sk: -------------------------------------------------------------------------------- 1 | bit oneSketch(bit[4] in) implements one { 2 | return in[3]; 3 | } 4 | 5 | 6 | bit one (bit[4] in) { 7 | return in[3]; 8 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/opt/plus.sk: -------------------------------------------------------------------------------- 1 | void main(int dummy) implements one{ 2 | 3 | int a = (dummy + dummy) + dummy; 4 | 5 | int b = dummy + (dummy + dummy); 6 | 7 | int c = a - b; 8 | 9 | assert c == 0; 10 | } 11 | 12 | void one (int dummy) { 13 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/opt/plusMultiVar.sk: -------------------------------------------------------------------------------- 1 | void main(int a, int b) implements one{ 2 | 3 | int x = (a + b) + (b + 3); 4 | 5 | int y = ((b + b) + 2); 6 | 7 | int z = x - y; 8 | 9 | assert z == a + 1; 10 | } 11 | 12 | void one (int a, int b) { 13 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/sketchTests/regtests/miniTest76.sk: -------------------------------------------------------------------------------- 1 | 2 | bit test(int in) implements spec{ 3 | return in == in; 4 | } 5 | 6 | bit spec(int in){ 7 | if (in >= -2147483646) 8 | return in > in-1; 9 | return 1; 10 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/sketchTests/regtests/miniTest80.sk: -------------------------------------------------------------------------------- 1 | 2 | bit test(int in) implements spec{ 3 | return in == in; 4 | } 5 | 6 | bit spec(int in){ 7 | if (in >= -2147483646) 8 | return in-1 > in-2; 9 | return 1; 10 | } -------------------------------------------------------------------------------- /src/test/deprecated/smt/sketchTests/regtests/miniTestb124.sk: -------------------------------------------------------------------------------- 1 | int spec(int i){ 2 | return i; 3 | } 4 | 5 | int sketch(int i) implements spec{ 6 | int nv = i; 7 | if(i > 2 && i < 2147483647){ 8 | nv = i + 1; 9 | assert nv > i; 10 | } 11 | return i; 12 | } -------------------------------------------------------------------------------- /src/test/deprecated/sten/Makefile: -------------------------------------------------------------------------------- 1 | test-solver: 2 | bash ./regtest.sh 3 | test-cgen: 4 | bash ./regtest2.sh 5 | clean: 6 | ./clean.sh 7 | -------------------------------------------------------------------------------- /src/test/deprecated/sten/clean.sh: -------------------------------------------------------------------------------- 1 | #! /usr/bin/bash 2 | rm -f script *.h *.exe *.stackdump *.c *.cpp *.cc *.sout *.output *.blif 3 | for FILE in *.sk; do rm -f ${FILE%.sk}; done 4 | 5 | 6 | -------------------------------------------------------------------------------- /src/test/sk/numerical/Makefile: -------------------------------------------------------------------------------- 1 | IPATH=../../../ 2 | RTIME=../../../ 3 | 4 | 5 | 6 | include ../../../testrunner.mk 7 | -------------------------------------------------------------------------------- /src/test/sk/numerical/clean.sh: -------------------------------------------------------------------------------- 1 | rm -f *.cpp *.h *.output *.exe *.eout *.stackdump 2 | -------------------------------------------------------------------------------- /src/test/sk/seq/Makefile: -------------------------------------------------------------------------------- 1 | IPATH=../../../ 2 | RTIME=../../../ 3 | 4 | 5 | 6 | 7 | include ../../../testrunner.mk 8 | -------------------------------------------------------------------------------- /src/test/sk/seq/clean.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | rm -f script *.h *.exe *.eout *.stackdump *.c *.cpp *.cc *.sout *.output *.tmp *.orig 3 | # for FILE in *.sk; do rm -f ${FILE%.sk}; done 4 | 5 | 6 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest1.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[4] in) implements reverse { 2 | return (in[1] & ??) | (in[3] & ??); 3 | } 4 | 5 | 6 | bit reverse (bit[4] in) { 7 | return in[3]; 8 | } 9 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest13.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[5] in) implements reverse { 2 | int i1 = {*}; 3 | int i2 = {*}; 4 | return in[i1*i2]^in[i1]; 5 | } 6 | 7 | 8 | bit reverse (bit[5] in) { 9 | return in[4]^in[2]; 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest14.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[4] in) implements reverse { 2 | bit t=0; 3 | int i=0; 4 | repeat(??){ 5 | t = in[i]; 6 | i = i+1; 7 | } 8 | return t; 9 | } 10 | 11 | 12 | bit reverse (bit[4] in) { 13 | return in[2]; 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest15.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[4] in) implements reverse { 2 | bit [2] tmp = 0; 3 | tmp[0] = {*}; 4 | tmp[1] = {*}; 5 | return in[(int)tmp]; 6 | } 7 | 8 | 9 | bit reverse (bit[4] in) { 10 | return in[3]; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest19.sk: -------------------------------------------------------------------------------- 1 | generator bit[4] foo(bit[4] in){ /* automatically rewritten */ 2 | return in; 3 | } 4 | 5 | bit[4] reverseSketch(bit[4] in) implements reverse { 6 | return in ^ foo(1); 7 | } 8 | 9 | 10 | bit[4] reverse (bit[4] in) { 11 | return in^1; 12 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest199Includes.skh: -------------------------------------------------------------------------------- 1 | generator bit VOID(bit a, bit b, bit c){ /* automatically rewritten */ 2 | return (a & !b) & (!b & c); 3 | } 4 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest2.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[4] in) implements reverse { 2 | bit [4] tmp = in; 3 | tmp[2] = 1; 4 | tmp[3] = 0; 5 | return tmp[{*}]; 6 | } 7 | 8 | bit reverse (bit[4] in) { 9 | return in[1]; 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest20.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[5] in) implements reverse { 2 | int [4] fu = { 2, 3, 4, 0 }; 3 | int idx1 = ??(2); 4 | int idx = fu[ idx1 ]; 5 | return in[ idx ]; 6 | } 7 | 8 | 9 | bit reverse (bit[5] in) { 10 | return in[4]; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest207MainMethodAndPragma.sk: -------------------------------------------------------------------------------- 1 | harness void main1(int x) { /* automatically rewritten */ 2 | assert(x - x + ?? == 3); 3 | } 4 | 5 | harness int main2(int x) { /* automatically rewritten */ 6 | int v = ??; 7 | assert(v + 1 == 3 - 1); 8 | return v; 9 | } 10 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest211ExprArrayInit.sk: -------------------------------------------------------------------------------- 1 | int[2] f(int x,int y) { return {x,y}; } 2 | 3 | harness void main(int in_) { 4 | int[2] array2 = f(-3, 4); 5 | int x = array2[??]; 6 | assert x + in_ == in_ + ??; 7 | } 8 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest212IndexOffsetBug.sk: -------------------------------------------------------------------------------- 1 | bit f(int pivot, int width) { 2 | int[1] input = {2}; 3 | return input[pivot - width + 1] == 2; 4 | } 5 | 6 | harness void main() { 7 | assert(f(1, 2)); 8 | } 9 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest22.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[4] in) implements reverse { 2 | int x; 3 | if(??){ 4 | x = ??; 5 | }else{ 6 | x = 1; 7 | } 8 | return in[x]; 9 | } 10 | 11 | 12 | bit reverse (bit[4] in) { 13 | return in[2]; 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest24.sk: -------------------------------------------------------------------------------- 1 | bit testSK(bit[4] in) implements test { 2 | int x = ??; 3 | int y = ??; 4 | assert y < 1; 5 | if( x > 2){ 6 | return in[3]; 7 | }else{ 8 | return in[y*2]; 9 | } 10 | } 11 | 12 | 13 | bit test (bit[4] in) { 14 | return in[3]; 15 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest26.sk: -------------------------------------------------------------------------------- 1 | bit[3] miniTest(bit[3] in) { 2 | bit[2] one = {0, 0}; 3 | one[0] = 1; 4 | return in ^ one; 5 | } 6 | 7 | 8 | bit[3] miniTestSK (bit[3] in) implements miniTest{ 9 | bit[2] one = {0, 0}; 10 | one[0] = ??; 11 | return in ^ one; 12 | } 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest3.sk: -------------------------------------------------------------------------------- 1 | bit[4] simple(bit[3*4] in) implements simpler 2 | { 3 | bit[4] i1; 4 | bit x = 1; 5 | if(in[0]){ 6 | x = 0; 7 | } 8 | i1 = x; 9 | return i1; 10 | } 11 | 12 | bit[4] simpler(bit[3*4] in){ 13 | return !in[0]; 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest33.sk: -------------------------------------------------------------------------------- 1 | bit[4] miniTest(bit[4] in) { 2 | in[2] = 1; 3 | return in; 4 | } 5 | 6 | 7 | bit[4] miniTestSK (bit[4] in) implements miniTest{ 8 | in[??] = 1; 9 | return in; 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest34.sk: -------------------------------------------------------------------------------- 1 | bit miniTest(bit[4] in) { 2 | return in[2]; 3 | } 4 | 5 | 6 | bit miniTestSK (bit[4] in) implements miniTest{ 7 | int[3] fu = {0, 1, 3}; 8 | fu[??] = 2; 9 | return in[fu[2]]; 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest35.sk: -------------------------------------------------------------------------------- 1 | bit miniTest(bit[4] in) { 2 | return in[2]; 3 | } 4 | 5 | 6 | bit miniTestSK (bit[4] in) implements miniTest{ 7 | int[3] fu = {0, 1, 3}; 8 | fu[??] = ??; 9 | return in[fu[2]]; 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest36.sk: -------------------------------------------------------------------------------- 1 | bit miniTest(bit[4] in) { 2 | return in[2]; 3 | } 4 | 5 | 6 | bit miniTestSK (bit[4] in) implements miniTest{ 7 | int[3] fu = {0, 1, 3}; 8 | fu[2] = ??; 9 | return in[fu[??]]; 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest37.sk: -------------------------------------------------------------------------------- 1 | bit miniTest(bit[4] in) { 2 | return in[2]; 3 | } 4 | 5 | 6 | bit miniTestSK (bit[4] in) implements miniTest{ 7 | int[2] fu = {0, 1}; 8 | fu[??] = ??; 9 | assert fu[1] > 1; 10 | return in[fu[??]]; 11 | } 12 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest38.sk: -------------------------------------------------------------------------------- 1 | bit[4] miniTest(bit[4] in, bit[2] in2) { 2 | int i = (int) in2; 3 | in[i] = 1; 4 | return in; 5 | } 6 | 7 | 8 | bit[4] miniTestSK (bit[4] in, bit[2] in2) implements miniTest{ 9 | int i = (int) in2; 10 | in[i] = ??; 11 | return in; 12 | } 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest4.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[4] in) implements reverse { 2 | bit [4] tmp = in >> {*}; 3 | return tmp[0]; 4 | } 5 | 6 | bit reverse (bit[4] in) { 7 | return in[2]; 8 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest5.sk: -------------------------------------------------------------------------------- 1 | generator bit foo(bit[4] ina){ /* automatically rewritten */ 2 | return ina[{*}]; 3 | } 4 | 5 | bit reverseSketch(bit[4] in) implements reverse { 6 | return foo(in) ^ foo(in); 7 | } 8 | 9 | bit reverse (bit[4] in) { 10 | return in[2] ^ in[3]; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest53.sk: -------------------------------------------------------------------------------- 1 | bit[3] miniTest(bit[3] in) { 2 | bit [3] tmp = {0, 1, 1}; 3 | return in ^ tmp; 4 | } 5 | 6 | 7 | bit[3] miniTestSK (bit[3] in) implements miniTest{ 8 | bit [3] tmp = {0, 0, 0}; 9 | bit [2] two = ??; 10 | tmp[1::2] = two; 11 | return in ^ tmp; 12 | } 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest6.sk: -------------------------------------------------------------------------------- 1 | int W = 4; 2 | 3 | bit[4] reverseSketch(bit[4] in) implements reverse { 4 | return in + {*} + in; 5 | } 6 | 7 | bit[4] reverse (bit[4] in) { 8 | bit[4] tmp = {0, 1, 0, 0}; 9 | return in + tmp+in; 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest61.sk: -------------------------------------------------------------------------------- 1 | bit alwaysOne(bit[3] x) 2 | { 3 | return x[2]; 4 | } 5 | 6 | bit test2(bit[3] x) implements alwaysOne 7 | { 8 | bit tt = ??; 9 | bit uu = ??; 10 | x[1] = (!tt) ^ x[2]; 11 | return x[uu]; 12 | } 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest7.sk: -------------------------------------------------------------------------------- 1 | bit[4] reverseSketch(bit[4] in) implements reverse { 2 | bit[4] tmp1 = {0, 0, 1, 0}; 3 | return in + {*} + tmp1; 4 | } 5 | 6 | bit[4] reverse (bit[4] in) { 7 | bit[4] tmp1 = {0, 1, 1, 0}; 8 | bit[4] tmp2 = {1, 1, 0, 0}; 9 | return in + tmp1+tmp2; 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest75.sk: -------------------------------------------------------------------------------- 1 | int W = 7; 2 | 3 | bit[W] debug(bit[W] in) implements swap { 4 | bit[W] tmp = (in ^ !in); 5 | return (tmp << 5); 6 | } 7 | 8 | 9 | 10 | bit[W] swap (bit[W] in) { 11 | return ((in ^ !in)<<5); 12 | } 13 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest76.sk: -------------------------------------------------------------------------------- 1 | 2 | bit test(int in) implements spec{ 3 | return in == in; 4 | } 5 | 6 | bit spec(int in){ 7 | return in > in-1; 8 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest77.sk: -------------------------------------------------------------------------------- 1 | 2 | int test(int in, bit i2) implements spec{ 3 | int t = i2 ? 1 : 2; 4 | return ((in+1) - t) + 1; 5 | } 6 | 7 | int spec(int in, bit i2){ 8 | int t = i2 ? 0 : 1; 9 | return (in+1) - t; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest80.sk: -------------------------------------------------------------------------------- 1 | 2 | bit test(int in) implements spec{ 3 | return in == in; 4 | } 5 | 6 | bit spec(int in){ 7 | return in-1 > in-2; 8 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest89.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | int test(int in1, int in2) implements spec{ 4 | return (in1+ in2); 5 | } 6 | 7 | int spec(int in1, int in2){ 8 | return (in1+in2); 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest9.sk: -------------------------------------------------------------------------------- 1 | bit reverseSketch(bit[4] in) implements reverse { 2 | 3 | in = in << 1; 4 | in = in >> {*}; 5 | in = in << 1; 6 | return in[3]; 7 | } 8 | 9 | bit reverse (bit[4] in) { 10 | return in[2]; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest90.sk: -------------------------------------------------------------------------------- 1 | int W = 4; 2 | 3 | bit[W] 4 | first (bit[W] x, bit[W] y) 5 | { 6 | return x; 7 | } 8 | 9 | bit[W] 10 | first_sk (bit[W] x, bit[W] y) implements first 11 | { 12 | bit choice = ??; 13 | return (choice ? x : y); 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest91.sk: -------------------------------------------------------------------------------- 1 | int W = 4; 2 | 3 | bit[W] 4 | first (bit[W] x, bit[W] y) 5 | { 6 | return x; 7 | } 8 | 9 | bit[W] 10 | first_sk (bit[W] x, bit[W] y) implements first 11 | { 12 | return ((0 == 0) ? x : y); 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest93.sk: -------------------------------------------------------------------------------- 1 | int moo(int x); /* Uninterpreted function.*/ /* automatically rewritten */ 2 | 3 | 4 | int foo(int x){ 5 | return moo(x + x + x); 6 | } 7 | 8 | int fooSK(int x) implements foo{ 9 | return moo(??*x); 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest94.sk: -------------------------------------------------------------------------------- 1 | bit[5] reverseSketch(bit[5] in1, bit[5] in2) implements reverse { 2 | return ?? ? in1 : in2; 3 | } 4 | 5 | 6 | bit[5] reverse (bit[5] in1, bit[5] in2) { 7 | return in1; 8 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest96.sk: -------------------------------------------------------------------------------- 1 | 2 | int foo(int i) implements boo{ 3 | int x = -1; 4 | if(??){ 5 | x = 0; 6 | } 7 | return x + i; 8 | } 9 | 10 | 11 | int boo(int i){ 12 | return i-1;; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest97.sk: -------------------------------------------------------------------------------- 1 | 2 | int foo(int i) implements boo{ 3 | int x = -8; 4 | if(??){ 5 | x = x + 1; 6 | } 7 | return x + i; 8 | } 9 | 10 | 11 | int boo(int i){ 12 | return i-7;; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest98.sk: -------------------------------------------------------------------------------- 1 | 2 | int foo(int i) implements boo{ 3 | int x = -7; 4 | if(??){ 5 | x = 0; 6 | } 7 | return x + i; 8 | } 9 | 10 | 11 | int boo(int i){ 12 | return i-7;; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTest99.sk: -------------------------------------------------------------------------------- 1 | 2 | int foo(int i) implements boo{ 3 | int x = -7; 4 | if(??){ 5 | x = 1; 6 | } 7 | return x + i; 8 | } 9 | 10 | 11 | int boo(int i){ 12 | return i-7;; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestBigInts1.sk: -------------------------------------------------------------------------------- 1 | harness void main(int x, int y){ 2 | int t = {| x + y | x * y |}; 3 | int q = {| t + x | t + y | t * ?? |}; 4 | 5 | assert q == 3*x + 3*y; 6 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestBigInts7.sk: -------------------------------------------------------------------------------- 1 | 2 | harness void main(){ 3 | int x = ??; 4 | int y = ??; 5 | int t = x + y; 6 | assert t < 5; 7 | int q = {1,1,1,1,1,1,1,1,t, 9}[x]; 8 | int v = q * 100; 9 | int u = x * v; 10 | assert x > 3; 11 | assert u == ??(9); 12 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb105.sk: -------------------------------------------------------------------------------- 1 | bit foo(int arr, bit org){ 2 | return (1 == arr) && org; 3 | } 4 | 5 | bit fooSK(int arr, bit org) implements foo{ 6 | return (?? == arr) && org; 7 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb106.sk: -------------------------------------------------------------------------------- 1 | bit foo(int arr, bit org){ 2 | return (3 == arr) && org; 3 | } 4 | 5 | bit fooSK(int arr, bit org) implements foo{ 6 | return (?? == arr) && org; 7 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb108.sk: -------------------------------------------------------------------------------- 1 | 2 | bit foo(bit in) implements ka{ 3 | bit[4] f = {1,1,0,1}; 4 | f[2] = in; 5 | int[2] tt = {3, 2}; 6 | int t = ??; 7 | assert t > 1; 8 | return f[t<2? tt[ t] : 0]; 9 | } 10 | 11 | bit ka(bit in){ 12 | return 1; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb109.sk: -------------------------------------------------------------------------------- 1 | 2 | bit foo(bit in) implements ka{ 3 | bit[4] f = {1,1,0,1}; 4 | f[0] = in; 5 | int[2] tt = {3, 2}; 6 | int t = ??; 7 | assert t > 1; 8 | return f[t<2? tt[ t] : 0]; 9 | } 10 | 11 | bit ka(bit in){ 12 | return in; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb111.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | struct Node{ 4 | int val; 5 | int next; 6 | } 7 | 8 | int test(int i){ 9 | Node n = new Node(); 10 | n.val = i; 11 | return n.val; 12 | } 13 | 14 | int rest(int i) implements test{ 15 | 16 | return i; 17 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb124.sk: -------------------------------------------------------------------------------- 1 | int spec(int i){ 2 | return i; 3 | } 4 | 5 | int sketch(int i) implements spec{ 6 | int nv = i; 7 | if(i > 2){ 8 | nv = i + 1; 9 | assert nv > i; 10 | } 11 | return i; 12 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb127.sk: -------------------------------------------------------------------------------- 1 | int spec(int i){ 2 | return i; 3 | } 4 | 5 | generator void foo(int i, ref int x){ /* automatically rewritten */ 6 | x = i; 7 | } 8 | 9 | int sketch(int i) implements spec{ 10 | 11 | int x = 1; 12 | foo(i, x); 13 | return x; 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb136.sk: -------------------------------------------------------------------------------- 1 | 2 | bit test(bit a, bit b, bit c, bit d){ 3 | return (a & b) & (c & d); 4 | } 5 | 6 | bit sk(bit a, bit b, bit c, bit d) implements test{ 7 | 8 | return ?? & (( (a & c) & b ) & d); 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb139.sk: -------------------------------------------------------------------------------- 1 | int moo(int i){ 2 | 3 | return i; 4 | } 5 | 6 | 7 | 8 | int foo(int i) implements moo{ 9 | int t = ??; 10 | 11 | if( 2*i == (i+1)-i ){ 12 | assert t == 3; 13 | } 14 | 15 | return i + t; 16 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb140.sk: -------------------------------------------------------------------------------- 1 | 2 | int test(int in){ 3 | return in; 4 | } 5 | 6 | int sk(int in) implements test{ 7 | assert in + ?? == in + 2 - ??; 8 | return in; 9 | } 10 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb143.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-intbits 32"; 2 | int spec (int in) { 3 | return ((in + 1) * 2) / 3; 4 | } 5 | 6 | int sketch (int in) implements spec { 7 | insert { in = in * 2; } 8 | into { in = in + 1; in = in / 3; } 9 | return in; 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb144.sk: -------------------------------------------------------------------------------- 1 | int spec (int in) { 2 | return (((in + 1) * 2) / 3); 3 | } 4 | 5 | int sketch (int in) implements spec { 6 | reorder { 7 | in = in * 2; 8 | in = in / 3; 9 | in = in + 1; 10 | } 11 | return in; 12 | } 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb145.sk: -------------------------------------------------------------------------------- 1 | 2 | struct foo{ 3 | foo x; 4 | } 5 | 6 | 7 | bit one(){ 8 | return 1; 9 | } 10 | 11 | bit t() implements one{ 12 | foo t = new foo(); 13 | foo v = new foo(); 14 | 15 | return t.x == null && v.x == null; 16 | } 17 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb146.sk: -------------------------------------------------------------------------------- 1 | // Used to be a parser error; -?? was rejected. 2 | 3 | int spec () { return -1; } 4 | int sk () implements spec { return -??; } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb148.sk: -------------------------------------------------------------------------------- 1 | // Used to be a problem with operator precedences. 2 | 3 | bit spec (bit a, bit b, bit c, bit d) { 4 | return (a | (b ^ (c & d))); 5 | } 6 | bit sk (bit a, bit b, bit c, bit d) implements spec { 7 | return a | b ^ c & d; 8 | } 9 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb149.sk: -------------------------------------------------------------------------------- 1 | // Used to be a parser error: cast expressions had lower precedence than 2 | // shift expressions. 3 | 4 | int spec () { return 1; } 5 | int sk () implements spec { 6 | bit shft = ??; 7 | bit[1] tmp = (1 << (int) shft); 8 | return tmp[0]; 9 | } 10 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb154.sk: -------------------------------------------------------------------------------- 1 | 2 | bit foo(bit x, bit y){ 3 | 4 | 5 | 6 | bit t = y & x; 7 | if(y){ 8 | t = y; 9 | } 10 | return t; 11 | } 12 | 13 | 14 | bit moo(bit x, bit y) implements foo{ 15 | 16 | return (y & x) || y; 17 | 18 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb165.sk: -------------------------------------------------------------------------------- 1 | 2 | int foo(int x, int y){ 3 | 4 | return y + 4; 5 | } 6 | 7 | int too(int x, int y) implements foo{ 8 | int[4] A = 0; 9 | 10 | if( x >= 4){ x = 3; } 11 | 12 | A[x] = y; 13 | for(int i=0; i<4; ++i){ A[i] = A[i] + 4;} 14 | 15 | return A[x]; 16 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb167.sk: -------------------------------------------------------------------------------- 1 | bit ONE(int in){ 2 | return 1; 3 | } 4 | 5 | bit test(int in) implements ONE{ 6 | int n = in; 7 | if(?? && n == in){ 8 | int q = n; 9 | q = q; 10 | n = q+1; 11 | } 12 | assert n == in+1; 13 | return 1; 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb183.sk: -------------------------------------------------------------------------------- 1 | 2 | bit spec(int x, int y){ 3 | return x + 5 > y; 4 | } 5 | 6 | bit sk1(int x, int y) implements spec{ 7 | return x + ?? > y; 8 | } 9 | 10 | 11 | bit sk2(int x, int y) implements spec{ 12 | return x + 20 - ?? > y; 13 | } 14 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb186.sk: -------------------------------------------------------------------------------- 1 | int ufu(int a);/* Uninterpreted function */ /* automatically rewritten */ 2 | 3 | int faa(int s){ 4 | return ufu(s) * ufu(s+1); 5 | } 6 | 7 | int sk(int s) implements faa{ 8 | return ufu(s) * ufu(s+1); 9 | } 10 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb199.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 6 "; 2 | 3 | bit VOID(bit a, bit b, bit c){ 4 | return (a & !b) & (!b & c); 5 | } 6 | 7 | bit main_fun(bit a, bit b, bit c) implements VOID{ 8 | return (a & c) & !b; 9 | } 10 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb200.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 6 "; 2 | 3 | bit VOID(bit a, bit b, bit c){ 4 | return (a | !b) | (!b | c); 5 | } 6 | 7 | bit main_fun(bit a, bit b, bit c) implements VOID{ 8 | return (a | c) | !b; 9 | } 10 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb211.sk: -------------------------------------------------------------------------------- 1 | bit foo() 2 | { 3 | bit[4] x = {1,1,1,1}; 4 | bit[4] y = {1,0,1,0}; 5 | return x+y == y+x; 6 | } 7 | 8 | 9 | bit fooSK() implements foo{ 10 | return ??; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb212.sk: -------------------------------------------------------------------------------- 1 | bit foo(){ 2 | bit[3] x = {1,1,1}; 3 | bit[3] y = {1,1,0}; 4 | 5 | if (x==y){ 6 | return 1; 7 | } 8 | 9 | return 0; 10 | } 11 | 12 | bit fooSK() implements foo{ 13 | return ??; 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb213.sk: -------------------------------------------------------------------------------- 1 | bit foo(){ 2 | return 1; 3 | } 4 | 5 | bit fooSK() implements foo{ 6 | bit[3] x = {1,1,1}; 7 | bit[3] y = {1,0,1}; 8 | 9 | bit z; 10 | z = x == y; 11 | 12 | return 1; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb214.sk: -------------------------------------------------------------------------------- 1 | bit foo(){ 2 | bit[3] x = {1,1,1}; 3 | bit[2] y = {1,1}; 4 | 5 | if (x==y){ 6 | return 1; 7 | } 8 | 9 | return 0; 10 | } 11 | 12 | bit fooSK() implements foo{ 13 | return ??; 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb215.sk: -------------------------------------------------------------------------------- 1 | bit foo(bit[3] x, bit[3] y) implements fooSK{ 2 | bit z = x ==y; 3 | bit w = x+y == x; 4 | 5 | return (x == y? (z - 1 + ??)==1: (w - 1 + ??)==1); 6 | } 7 | 8 | bit fooSK(bit[3] x, bit[3] y){ 9 | return (x == y? x==y:x+y == x); 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb217.sk: -------------------------------------------------------------------------------- 1 | void test() implements main { 2 | int i = 1; 3 | while (??) { 4 | i = 10; 5 | } 6 | return; 7 | } 8 | 9 | void main() { 10 | return; 11 | } 12 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb218.sk: -------------------------------------------------------------------------------- 1 | harness void main(int i){ 2 | i = i-25; 3 | if(i < 0){ return; } 4 | while(i != 0){ 5 | i = i-1; 6 | } 7 | assert i == 0; 8 | } 9 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb219.sk: -------------------------------------------------------------------------------- 1 | harness void lala(int x) 2 | { 3 | int t = x * ??; 4 | assert (t == x + x); 5 | } 6 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb220_harnesses.sk: -------------------------------------------------------------------------------- 1 | pragma options "-V10 --be:showDAG --be:nosim --fe-keep-tmp"; 2 | 3 | harness void f(){ 4 | int t = ??; 5 | assert t > 0 && t < 2; 6 | } 7 | 8 | harness void g(){ 9 | int x = ??; 10 | assert x > 0; 11 | } 12 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb222.sk: -------------------------------------------------------------------------------- 1 | 2 | int hole1(){ 3 | return ??; 4 | } 5 | 6 | int hole2(){ 7 | return ??; 8 | } 9 | 10 | harness void test1(){ 11 | assert hole1() + hole2() == 10; 12 | } 13 | 14 | harness void test2(){ 15 | assert hole2() == 5; 16 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb227.sk: -------------------------------------------------------------------------------- 1 | harness void main(int t){ 2 | int[3] A; 3 | int i=0; 4 | repeat(??){ 5 | for(int x=0; x<10; ++x){ 6 | A[i] = x; 7 | } 8 | i = i+1; 9 | } 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb265.sk: -------------------------------------------------------------------------------- 1 | struct F{ 2 | int[20] q; 3 | } 4 | 5 | harness void main(int x){ 6 | int p = 0; 7 | if(x < 10){ 8 | int t = x + 1; 9 | F f = new F(); 10 | f.q = {1,2,3,4,5,6}; 11 | p = f.q[t]; 12 | } 13 | assert p < ??; 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb266.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inbits 3"; 2 | 3 | harness void test(int N, int [N] a){ 4 | 5 | int[N+??] b = a; 6 | assert b[N] == 0; 7 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb268.sk: -------------------------------------------------------------------------------- 1 | harness void main() { 2 | int[2] X = { ??, ?? }; 3 | test(X); 4 | assert X[0] == 2; 5 | assert X[1] == ??; 6 | } 7 | void test(int[2] t){ 8 | 9 | } 10 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb269.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inbits 3"; 2 | 3 | harness void main(int i, int N){ 4 | int x = 0; 5 | if(i3){ return; } 16 | foo2(i); 17 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb281.sk: -------------------------------------------------------------------------------- 1 | 2 | harness void main(int x){ 3 | int t = x / 2; 4 | //int y=0; 5 | if(x > 0){ 6 | int y = 2 / x; 7 | if(x != 2){ 8 | assert t != y; 9 | } 10 | } 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb290.sk: -------------------------------------------------------------------------------- 1 | include "miniTestb290a.skh"; 2 | include "miniTestb290b.skh"; 3 | 4 | 5 | 6 | harness void test(int a, int b){ 7 | int x = foo(a) + moo(b) + boo(a,b); 8 | assert x == a + b + a; 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb290a.skh: -------------------------------------------------------------------------------- 1 | package FOO; 2 | 3 | 4 | int foo(int x){ 5 | return x; 6 | } 7 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb290b.skh: -------------------------------------------------------------------------------- 1 | package BOO_MOO; 2 | 3 | int moo(int y){ 4 | return y; 5 | } 6 | 7 | generator int boo(int x, int y){ 8 | return ?? * x + ?? * y; 9 | } 10 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb293.sk: -------------------------------------------------------------------------------- 1 | include "miniTestb293a.skh"; 2 | 3 | int boo(int x, int y, fun f){ 4 | return ?? * f(x) + ?? * f(y); 5 | } 6 | 7 | 8 | harness void test(int a, int b){ 9 | int x = foo(a) + moo(b) + boo(a,b, foo); 10 | assert x == a + b + a; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb293a.skh: -------------------------------------------------------------------------------- 1 | package BOOPKG; 2 | 3 | int boo(int x){ 4 | return x; 5 | } 6 | 7 | int foo(int x){ 8 | return boo(x); 9 | } 10 | 11 | generator int moo(int x){ 12 | return x; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb294.sk: -------------------------------------------------------------------------------- 1 | include "miniTestb294a.skh"; 2 | 3 | harness void main( int v){ 4 | 5 | F t = new F(); 6 | setX(t, v); 7 | assert v == getX(t); 8 | 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb294a.skh: -------------------------------------------------------------------------------- 1 | package BOO; 2 | 3 | struct F{ 4 | int x; 5 | int y; 6 | } 7 | 8 | int getX(F pthis){ 9 | return pthis.x; 10 | } 11 | 12 | void setX(F pthis, int v){ 13 | pthis.x = v; 14 | } 15 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb298.sk: -------------------------------------------------------------------------------- 1 | include "miniTestb290a.skh"; 2 | 3 | int sk(int x) implements foo{ 4 | return x - 2 + ??; 5 | } 6 | 7 | int sk2(int x){ 8 | return sk(x) + sk(x); 9 | } 10 | 11 | int sk3(int x) implements sk2{ 12 | return ??*sk(x); 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb299.sk: -------------------------------------------------------------------------------- 1 | include "generators.skh"; 2 | 3 | pragma options "-V 5 --bnd-inline-amnt 2 --bnd-inbits 3 "; 4 | 5 | harness void testComp(int a, int b, int c){ 6 | bit t = (a>b) || (a+c > b+a); 7 | assert exprBool({a,b,c}, {PLUS})==t; 8 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb300.sk: -------------------------------------------------------------------------------- 1 | include "generators.skh"; 2 | 3 | pragma options "--bnd-inline-amnt 4 --bnd-inbits 3 "; 4 | 5 | 6 | 7 | 8 | harness void testComp(int a, int b, int c){ 9 | assert linexp(4, {a,b,c, 1}) == 10; 10 | assert linexp(4, {a,b,c, 1}) == a+b+4*c; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb304.sk: -------------------------------------------------------------------------------- 1 | 2 | harness void main(int in){ 3 | generator int foo(){ return in + ??; } 4 | 5 | 6 | assert foo() == (in + 3); 7 | 8 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb306.sk: -------------------------------------------------------------------------------- 1 | include "miniTestb306a.skh"; 2 | 3 | harness void main(int in1, int in2, int in3){ 4 | generator int foo(){ return {| in1 | in2 | in3 |}; } 5 | 6 | 7 | assert gen(foo) == (in1 + in3); 8 | 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb306a.skh: -------------------------------------------------------------------------------- 1 | package FUFU; 2 | 3 | generator int gen(fun f){ 4 | if(??){ 5 | return gen(f) + gen(f); 6 | } 7 | return f(); 8 | } 9 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb309.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | void foo(int N, ref int[N] bar){ 4 | assert bar[??] == 2; 5 | } 6 | 7 | harness void main(){ 8 | int N = 3; 9 | int[N] aa = {1, 2, 3}; 10 | foo(N, aa); 11 | foo(N, aa); 12 | assert aa[??] == 1; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb311.sk: -------------------------------------------------------------------------------- 1 | 2 | harness void main(int in){ 3 | int t = in+1; 4 | int x = t + 1; 5 | t = t -1; 6 | assert x == t + ??; 7 | 8 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb313.sk: -------------------------------------------------------------------------------- 1 | 2 | int foo(int in){ 3 | return in; 4 | } 5 | 6 | int moo(int in){ 7 | assert in == 0; 8 | return in; 9 | } 10 | 11 | harness void main(int in){ 12 | assert {| foo(in) | moo(in) |} == in; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb317.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inbits 3"; 2 | 3 | harness void main(int N, bit[N] ar){ 4 | bit[N] out = 0; 5 | int idx = 0; 6 | for(int i=0; i2){ 7 | assert foo() == (in[0] + 3); 8 | } 9 | 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb340.sk: -------------------------------------------------------------------------------- 1 | 2 | harness void test(int N, int[N] x){ 3 | if(30){ 5 | int[N] x; 6 | if(x[0]>??){ 7 | x[1] = 0; 8 | } 9 | assert x[??] == ??; 10 | x[??] = ??; 11 | assert x[??] == 3; 12 | } 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb372.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | harness void foo(int N){ 4 | if(N>0){ 5 | int[N] x; 6 | if(x[0]>??){ 7 | x[1] = 0; 8 | } 9 | assert x[??] == ??; 10 | x[??] = ??; 11 | assert x[??] == 3; 12 | } 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb390.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-inbits 3 --bnd-unroll-amnt 4"; 2 | 3 | harness void main(int x){ 4 | int t=0; 5 | int q=??(4); 6 | assert q <= 10; 7 | for(int i=0; i30; 9 | } 10 | 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb428.sk: -------------------------------------------------------------------------------- 1 | include "miniTestb428.skh"; 2 | 3 | struct Bar{ 4 | int aa; 5 | } 6 | 7 | harness void main(int i){ 8 | Moo m; 9 | m = getMe(i); 10 | assert m.x == i; 11 | } 12 | 13 | Moo getMe(int i){ 14 | Moo rv = new Moo(x=i); 15 | return rv; 16 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb428.skh: -------------------------------------------------------------------------------- 1 | package Foo; 2 | 3 | struct Bar{ 4 | int bb; 5 | } 6 | 7 | 8 | struct Moo{ 9 | int x; 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb429.sk: -------------------------------------------------------------------------------- 1 | include "miniTestb429a.skh"; 2 | include "miniTestb429b.skh"; 3 | 4 | 5 | harness void main(int i){ 6 | Jar j = newJar(i); 7 | assert j.x == i && j.b.x == i; 8 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb429a.skh: -------------------------------------------------------------------------------- 1 | package TOO; 2 | 3 | include "miniTestb429b.skh"; 4 | 5 | struct Bar{ 6 | int x; 7 | } 8 | 9 | Jar newJar(int i){ 10 | return new Jar(x=i, b=newBar(i)); 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb429b.skh: -------------------------------------------------------------------------------- 1 | package TOO; 2 | 3 | include "miniTestb429a.skh"; 4 | 5 | struct Jar{ 6 | int x; 7 | Bar b; 8 | } 9 | 10 | Bar newBar(int i){ 11 | return new Bar(x=i); 12 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb431.sk: -------------------------------------------------------------------------------- 1 | 2 | stencil int test(int i, int j){ 3 | int t = i + j; 4 | int q = t + 1; 5 | return q; 6 | } 7 | 8 | stencil int sk(int i, int j) implements test{ 9 | int t = i + j; 10 | int f = t +??; 11 | t = f - 1; 12 | return (t+f)-f; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb438.sk: -------------------------------------------------------------------------------- 1 | 2 | int f(int i){ 3 | return i; 4 | } 5 | int g(int i){ 6 | return i; 7 | } 8 | int h(int i){ 9 | return i; 10 | } 11 | 12 | harness void main(int i){ 13 | assert f(g(h(f(g(h(f(g(h(f(g(h(f(g(h(i+??))))))))))))))) == i+1; 14 | } 15 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb440.sk: -------------------------------------------------------------------------------- 1 | struct M{ 2 | int[2][2] x; 3 | } 4 | 5 | harness void main(int i){ 6 | M x = new M(); 7 | int[2] t = {x.x[0][0], x.x[0][1]}; 8 | assert t[0] == 0; 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb441.sk: -------------------------------------------------------------------------------- 1 | 2 | harness void main(double i, double j){ 3 | double a = i*j; 4 | double b = j*i; 5 | 6 | assert a + b == b + a; 7 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb442.sk: -------------------------------------------------------------------------------- 1 | pragma options "--be:showDAG"; 2 | 3 | bit[4] choices = ??; 4 | 5 | harness void main(int i){ 6 | if(i=0){ 3 | assert false; 4 | } 5 | } 6 | 7 | 8 | harness void main(int i){ 9 | if(i>2){ 10 | if(i*i < i){ 11 | foo(i); 12 | }else{ 13 | assert i==i; 14 | } 15 | } 16 | 17 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb464.sk: -------------------------------------------------------------------------------- 1 | //does not work 2 | harness void main(){ 3 | assert({1,2}!={2,3}); 4 | } 5 | 6 | //does work 7 | //harness void main(){ 8 | // assert(!({1,2}=={2,3})); 9 | //} 10 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb472.sk: -------------------------------------------------------------------------------- 1 | 2 | harness void main(int x){ 3 | int b; 4 | int z; 5 | int w; 6 | w = (((x+2)+5)-1); 7 | z = w + 1; 8 | b = w/2; 9 | w = b + 5; 10 | z = z + 1; 11 | assert b > 0; 12 | assert w > 4; 13 | assert z > 2; 14 | 15 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb474.sk: -------------------------------------------------------------------------------- 1 | void print(int n, char[n] x){ 2 | 3 | } 4 | 5 | 6 | harness void main(int x){ 7 | char[??] t = {'a', 'b', '\\' , '\n', '\'', 'a', '\'', '\0'}; 8 | 9 | print(??, t); 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb498.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 32 --be:showDAG"; 2 | 3 | harness void main(){ 4 | char[12] tt = ??; 5 | 6 | assert tt == "Hello world"; 7 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb499.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 32 --be:showDAG"; 2 | 3 | harness void main(){ 4 | char[20] tt = ??; 5 | assert tt[0::??] == "This is awesome!!"; 6 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb507.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 32"; 2 | 3 | int getLen([int n], int[n] x, int[n] y){ 4 | return n; 5 | } 6 | 7 | harness void main(int n, int[n] x){ 8 | int[n+23-??] y = x; 9 | assert getLen(x, y) == n+(??-??); 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb508.sk: -------------------------------------------------------------------------------- 1 | 2 | pragma options "--bnd-unroll-amnt 32"; 3 | 4 | int[3] getLen([int n, int m, int q], int[n][m][q] x){ 5 | return {n, m, q}; 6 | } 7 | 8 | harness void main(int n, int[n] x){ 9 | assert getLen(x) == {1, 1, n}; 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb511.skh: -------------------------------------------------------------------------------- 1 | package other; 2 | 3 | int x; 4 | 5 | void foo(){ 6 | x = 25; 7 | } 8 | 9 | void checkX(){ 10 | assert x == 25; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb513.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | harness void main(){ 4 | int[2] x = {5, 7}; 5 | int[4][3] y = x; 6 | assert y[0][0] == x[0]; 7 | assert y[1][0] == x[1]; 8 | assert y[1][1::3] == {0, 0, 0}; 9 | assert y[2] == {0, 0, 0, 0}; 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb518.sk: -------------------------------------------------------------------------------- 1 | 2 | int getLen([int n], int[n] x){ 3 | return n; 4 | } 5 | 6 | harness void main(int n, int[n] x){ 7 | assert !(getLen(x) == n+??); 8 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb520.sk: -------------------------------------------------------------------------------- 1 | 2 | harness void main(int n){ 3 | if(n>0){ return; } 4 | int[0] x; 5 | for(int i=0; i i){ 8 | return; 9 | } 10 | } 11 | 12 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb555.sk: -------------------------------------------------------------------------------- 1 | 2 | include "string.skh"; 3 | 4 | 5 | 6 | harness void main(int i){ 7 | Str h = newStr("hello "); 8 | Str hw = cat(h, newStr("world")); 9 | 10 | print(newStr("OUT: ")); 11 | println(hw); 12 | 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb556.sk: -------------------------------------------------------------------------------- 1 | 2 | harness void main(int i){ 3 | assume i>10; 4 | int x = ??; 5 | assert (i-10)%x == 0; 6 | } 7 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb557.in: -------------------------------------------------------------------------------- 1 | 1: This is a test 2 | 2: A great test -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb570.sk: -------------------------------------------------------------------------------- 1 | 2 | generator bit cond(int x, int y) { 3 | return {| x (< | == | > ) y |}; 4 | } 5 | harness void main() { 6 | int before = 2; 7 | int after = 1; 8 | assert cond(before, after); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb585.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | int[5] x = {1,2}; 4 | 5 | harness void main(){ 6 | assert x[3] == 0; 7 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb605a_adt.skh: -------------------------------------------------------------------------------- 1 | package BOO; 2 | 3 | struct Tree{ 4 | 5 | } 6 | 7 | struct Branch extends Tree{ 8 | Tree left; 9 | Tree right; 10 | } 11 | 12 | 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb610.sk: -------------------------------------------------------------------------------- 1 | 2 | pragma options "--bnd-inline-amnt 11"; 3 | 4 | 5 | harness void main(int i){ 6 | int foo(int x){ 7 | if(x>0){ 8 | return foo(x-1) + 1; 9 | }else{ 10 | return 1; 11 | } 12 | } 13 | 14 | assert foo(10) > ??; 15 | 16 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb612.sk: -------------------------------------------------------------------------------- 1 | 2 | bit bug3([int n], int[n] list, fun f) { 3 | return 0; 4 | } 5 | 6 | harness bit inv() { 7 | int[5] list; 8 | return bug3(list, bug3); 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb617.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | harness void test(int a){ 5 | 6 | int foo(int i){ return i+ 1; } 7 | 8 | int moo(int x, fun f){ 9 | int bar(){ 10 | int t = x + 1; 11 | return f(t); 12 | } 13 | return bar(); 14 | } 15 | 16 | assert moo(a, foo) == a + ??; 17 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb631.sk: -------------------------------------------------------------------------------- 1 | struct A{ 2 | } 3 | 4 | 5 | harness void main(){ 6 | A a = new A(); 7 | int[3] arr = a.{int}; 8 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb632.sk: -------------------------------------------------------------------------------- 1 | //works 2 | struct A{ 3 | 4 | } 5 | struct B extends A{ 6 | B b; 7 | } 8 | 9 | 10 | harness void main(){ 11 | B b = new B(); 12 | A[3] arr = b.{A}; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb633.sk: -------------------------------------------------------------------------------- 1 | //works 2 | struct A{ 3 | bit x; 4 | } 5 | 6 | 7 | harness void main(){ 8 | A a = new A(); 9 | int[3] arr = a.{bit}; 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb634.sk: -------------------------------------------------------------------------------- 1 | //works 2 | struct A{ 3 | bit x; 4 | } 5 | 6 | 7 | harness void main(bit t){ 8 | A a = new A(x=t); 9 | int[3] arr = a.{int}; // returns x field 10 | assert arr[??] == t; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb635.sk: -------------------------------------------------------------------------------- 1 | //works 2 | struct A{ 3 | int[3] x; 4 | } 5 | 6 | 7 | harness void main(){ 8 | A a = new A(); 9 | int[3][3] arr = a.{int[3]}; 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb648.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | pragma options "--bnd-unroll-amnt 100"; 4 | 5 | 6 | void foo(ref int[100] q){ 7 | q[77] = 25; 8 | } 9 | 10 | 11 | 12 | harness void main(int n, int[n] a){ 13 | int[100] m = a; 14 | 15 | foo(m); 16 | 17 | 18 | assert m[77] == 25; 19 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb649.sk: -------------------------------------------------------------------------------- 1 | //frontend test 2 | //should pass typechecking 3 | struct A{ 4 | @Immutable("") 5 | 6 | int x; 7 | } 8 | struct B extends A{ 9 | int y; 10 | } 11 | 12 | harness void main(int x){ 13 | B b = new B(y = 2); 14 | 15 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb650.sk: -------------------------------------------------------------------------------- 1 | //Simple immutable test 2 | struct A{ 3 | @Immutable("") 4 | int x; 5 | A nxt; 6 | } 7 | 8 | harness void main(int x){ 9 | A a = new A(x = 2); 10 | A b = new A(x =3, nxt = a); 11 | assert (b.nxt.x == 2); 12 | 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb658.sk: -------------------------------------------------------------------------------- 1 | 2 | struct A{@Immutable("") 3 | int x; 4 | A nxt; 5 | } 6 | 7 | 8 | 9 | harness void main(){ 10 | 11 | A a = new A(nxt = new A() ); 12 | A b= a.nxt; 13 | assert(b.x !=1); 14 | 15 | 16 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb663.sk: -------------------------------------------------------------------------------- 1 | struct A{ 2 | int x; 3 | 4 | } 5 | 6 | harness void main(){ 7 | A a = new A(); 8 | A[2] arr = {}; 9 | if(arr[0] != null){ 10 | A b = arr[0]; 11 | int x = b.x; // getting replaced to 0.x after partial evaluator pass 12 | } 13 | 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb666_adt.sk: -------------------------------------------------------------------------------- 1 | //Test that exposed bug with using structs in field that are not yet initialized 2 | struct A{} 3 | struct B extends A{ 4 | C c; 5 | } 6 | struct C{} 7 | struct D extends C{ 8 | } 9 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb667_adt.sk: -------------------------------------------------------------------------------- 1 | struct A{} 2 | struct B extends A{ 3 | C c; 4 | } 5 | struct C{} 6 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb677.sk: -------------------------------------------------------------------------------- 1 | struct A{int x;} 2 | struct B extends A{} 3 | harness void main(){ 4 | B a = new B(x = ??); 5 | assert(a.x == 1); 6 | 7 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb680.sk: -------------------------------------------------------------------------------- 1 | harness void main(int x){ 2 | 3 | assume x > 5; 4 | assert x > ??+3; 5 | assume x < 4; 6 | 7 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb690.sk: -------------------------------------------------------------------------------- 1 | harness void main(int n){ 2 | assume n == 6; 3 | int[n] tt = {1,2,3,4,5,6}; 4 | int x = tt[1]; 5 | tt[0::3] = tt[3::3]; 6 | tt[0] = x; 7 | assert tt[0] == ??; 8 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb693.sk: -------------------------------------------------------------------------------- 1 | 2 | struct A{} 3 | struct B extends A{} 4 | struct C extends A{} 5 | 6 | harness void main(){ 7 | 8 | A[3] a = {new B(), new C()}; 9 | 10 | 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb700.sk: -------------------------------------------------------------------------------- 1 | 2 | int y; 3 | int z; 4 | int fi(int x){ 5 | if(y > 0 && z > 0){ 6 | return x; 7 | }else{ 8 | return x; 9 | } 10 | } 11 | 12 | int foo(int x) implements fi{ 13 | return x +z*??; 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb701.sk: -------------------------------------------------------------------------------- 1 | bit[3] main(bit[3] x, bit[3] y){ 2 | return x + y; 3 | } 4 | 5 | bit[3] mainB(bit[3] x, bit[3] y) implements main{ 6 | bit[3] a=0; 7 | a += x; 8 | a += y; 9 | return a; 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb707.sk: -------------------------------------------------------------------------------- 1 | // Array in tuple 2 | struct A{ 3 | @Immutable("") 4 | int x; 5 | A nxt; 6 | int [5] y; 7 | } 8 | 9 | harness void main(int x){ 10 | A a = new A(x = 2); 11 | A b = new A(x =3, nxt = a); 12 | assert (b.nxt.x == 2); 13 | 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb708.sk: -------------------------------------------------------------------------------- 1 | //variable length array in tuple 2 | struct A{ 3 | @Immutable("") 4 | int x; 5 | A nxt; 6 | int n; 7 | int [n] y; 8 | } 9 | 10 | harness void main(int x){ 11 | A a = new A(x = 2); 12 | A b = new A(x =3, nxt = a); 13 | assert (b.nxt.x == 2); 14 | 15 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb714.sk: -------------------------------------------------------------------------------- 1 | 2 | package A{ 3 | int Y = X; 4 | harness void main(int in){ 5 | assert in + Y == in + ??; 6 | } 7 | 8 | } 9 | 10 | package B{ 11 | int X = 2; 12 | harness void main(int in){ 13 | assert in + X < in + 4; 14 | } 15 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb715.sk: -------------------------------------------------------------------------------- 1 | int moo = {| 10 | 20 |}; 2 | 3 | 4 | void foo(){ 5 | 6 | moo = moo + 10; 7 | } 8 | 9 | harness void main(int i){ 10 | foo(); 11 | int x = i + moo; 12 | assert x > i + 22; 13 | 14 | 15 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb716.sk: -------------------------------------------------------------------------------- 1 | 2 | package A{ 3 | int X = 5; 4 | harness void main(int in){ 5 | assert in + X > in + 4; 6 | } 7 | 8 | } 9 | 10 | package B{ 11 | int X = 2; 12 | harness void main(int in){ 13 | assert in + X < in + 4; 14 | } 15 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb717.sk: -------------------------------------------------------------------------------- 1 | 2 | package A{ 3 | 4 | harness void main(int in){ 5 | assert in + X == in + ??; 6 | } 7 | 8 | } 9 | 10 | package B{ 11 | int X = 2; 12 | harness void main(int in){ 13 | assert in + X < in + 4; 14 | } 15 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb725.sk: -------------------------------------------------------------------------------- 1 | // Testing how specialized functions are created 2 | 3 | int apply(fun f, int x){ 4 | return f(x); 5 | } 6 | 7 | int timesTwo(int x){ 8 | return x+x; 9 | } 10 | 11 | harness void main(int x){ 12 | assert apply(timesTwo, x) == 2*x; 13 | } 14 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb729.sk: -------------------------------------------------------------------------------- 1 | // Inlining a lambda expression and using it 2 | // multiple times 3 | 4 | harness void main(){ 5 | fun f = (x) -> x + 1; 6 | 7 | int x = f(3); 8 | int y = f(4); 9 | int z = f(x); 10 | 11 | assert x + y + z == 14; 12 | } 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb731.sk: -------------------------------------------------------------------------------- 1 | // Calling a lambda function inside a local function 2 | 3 | harness void main() { 4 | fun f = (x) -> x + 1; 5 | 6 | int g(int x) { 7 | int temp = f(1) + x; 8 | return temp; 9 | } 10 | 11 | assert g(1) == 3; 12 | } 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb732.sk: -------------------------------------------------------------------------------- 1 | // Calling a lambda function inside a local function 2 | 3 | harness void main() { 4 | fun f = (x) -> x + 1; 5 | 6 | int one = 1; 7 | 8 | int g(int i) { 9 | int temp = f(1) + i + one; 10 | return temp; 11 | } 12 | 13 | assert g(5) == 8; 14 | } 15 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb733.sk: -------------------------------------------------------------------------------- 1 | // Lambda expression uses a local variable 2 | 3 | int apply(fun f, int x) { 4 | return f(x); 5 | } 6 | 7 | harness void main(){ 8 | int t = 1; 9 | 10 | assert apply((x) -> x + t, 7) == 8; 11 | 12 | } 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb735.sk: -------------------------------------------------------------------------------- 1 | // Passing a local lambda to a function 2 | 3 | int apply(fun f, int x) { 4 | return f(x); 5 | } 6 | 7 | harness void main(){ 8 | fun f = (y) -> y + 5; 9 | 10 | assert apply(f, 5) == 10; 11 | } 12 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb745.sk: -------------------------------------------------------------------------------- 1 | // Calling a function that executes some lambda function 2 | 3 | int apply(fun f) { 4 | return f(); 5 | } 6 | 7 | int lambda1() { 8 | fun f = (x) -> x; 9 | 10 | return f(2); 11 | } 12 | 13 | harness void main(){ 14 | assert apply(lambda1) == 2; 15 | } 16 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb746.sk: -------------------------------------------------------------------------------- 1 | // Using a local function in the expression of a lambda function 2 | 3 | harness void main(){ 4 | 5 | int foo(int x) { 6 | return x + 1; 7 | } 8 | 9 | fun f = (y) -> foo(y) + 1; 10 | 11 | assert f(3) == 5; 12 | } 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb748.sk: -------------------------------------------------------------------------------- 1 | // Using a local variable construct in a lambda expression 2 | 3 | harness void main(int x){ 4 | int a = 2; 5 | int b = 3; 6 | 7 | fun f = () -> $(int) + $(int); 8 | 9 | assert f() == 2 * x; 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb749.sk: -------------------------------------------------------------------------------- 1 | // Local variable inside an local function 2 | 3 | harness void main(int x){ 4 | int a = 2; 5 | int b = 3; 6 | 7 | int foo() { 8 | return $(int); 9 | } 10 | 11 | assert foo() == x; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb750.sk: -------------------------------------------------------------------------------- 1 | // Using local variable inside an local 2 | // function with a formal parameter 3 | 4 | harness void main(int x){ 5 | int a = 2; 6 | int b = 3; 7 | 8 | int foo(int y) { 9 | return $(int); 10 | } 11 | 12 | assert foo(x) == x; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb753.sk: -------------------------------------------------------------------------------- 1 | // Testing that y = $(int) == f = (,) -> $(int); y = f(); 2 | 3 | harness void main() { 4 | int a = 4; 5 | int x = $(int); 6 | 7 | fun f = () -> $(int); 8 | int y = f(); 9 | 10 | assert y == x; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb754.sk: -------------------------------------------------------------------------------- 1 | // Finding variables of type int 2 | 3 | harness void localVariable(int x, int y) 4 | { 5 | int a = 2; 6 | int b = 3; 7 | int c = 4; 8 | 9 | int t = $(int)*??; 10 | 11 | assert (t == x + x); 12 | } 13 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb759.sk: -------------------------------------------------------------------------------- 1 | // General test of lambda 2 | 3 | int apply(fun f, int x) { 4 | return f(x); 5 | } 6 | 7 | harness void main(){ 8 | fun f = (y) -> y + 5; 9 | 10 | assert apply(f, 5) == 10; 11 | } 12 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb760.sk: -------------------------------------------------------------------------------- 1 | // Local variable picks variables that can be promoted 2 | // to the requested type 3 | 4 | harness void main(){ 5 | bit x = 1; 6 | 7 | fun f = () -> $(int) + 2; 8 | 9 | assert f() == 3; 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb763.sk: -------------------------------------------------------------------------------- 1 | // Using only local variables in a lambda 2 | 3 | harness void main() { 4 | int t = 3; 5 | 6 | fun f = () -> t + t; 7 | 8 | assert f() == 6; 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb764.sk: -------------------------------------------------------------------------------- 1 | // Using ternary expression and local variables in lambda 2 | 3 | harness void main(int x) { 4 | int a = 1; 5 | int b = 2; 6 | int t = 3; 7 | 8 | fun f = () -> ?? ? $(int)*$(int) : $(int) - 2; 9 | 10 | assert f() == x + x; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb765.sk: -------------------------------------------------------------------------------- 1 | // Using ternary expression in lambda 2 | 3 | harness void main() { 4 | int t = 3; 5 | 6 | fun f = () -> ?? ? t + t : t - 2; 7 | 8 | assert f() == 1; 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb768.sk: -------------------------------------------------------------------------------- 1 | // Casting an expression to a function 2 | 3 | int apply(fun f, int x, int y) { 4 | return f(x, y); 5 | } 6 | 7 | harness void main() { 8 | int a = 3; 9 | int b = 4; 10 | 11 | assert apply(a + b, 0, 0) == 7; 12 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb769.sk: -------------------------------------------------------------------------------- 1 | // No casting since it is passing a function 2 | 3 | int apply(fun f, int y) { 4 | return f(y); 5 | } 6 | 7 | harness void main() { 8 | int joe = 3; 9 | 10 | fun f = (t) -> t * 2; 11 | 12 | assert apply(f, 8) == 16; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb770.sk: -------------------------------------------------------------------------------- 1 | // Casting an expression to a function that passes a local variable 2 | 3 | int apply(fun f) { 4 | return f(); 5 | } 6 | 7 | harness void main() { 8 | int joe = 3; 9 | 10 | assert apply(joe) == 3; 11 | } 12 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb771.sk: -------------------------------------------------------------------------------- 1 | // Casting an expression to a function 2 | 3 | int apply(fun f) { 4 | int y = 8; 5 | 6 | return f(y); 7 | } 8 | 9 | harness void main() { 10 | int joe = 3; 11 | 12 | assert apply(joe) == 3; 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb772.sk: -------------------------------------------------------------------------------- 1 | // Casting an expression to a function 2 | 3 | int apply(fun f, int x, int y) { 4 | return f(x, y); 5 | } 6 | 7 | harness void main() { 8 | int t = 7; 9 | 10 | assert apply(t + t, 4, 3) == 14; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb773.sk: -------------------------------------------------------------------------------- 1 | // Casting an expression to a function that uses local variables 2 | 3 | int apply(fun f, int var, fun g) { 4 | int tops = g(); 5 | return tops; 6 | } 7 | 8 | harness void main(int x) { 9 | int t = 7; 10 | 11 | assert apply(5 + t, 45, t * t) == 49; 12 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb774.sk: -------------------------------------------------------------------------------- 1 | // Casting an expression to a function 2 | 3 | int apply(fun f, fun g) { 4 | return ?? ? f() : g(); 5 | } 6 | 7 | harness void main() { 8 | int a = 7; 9 | 10 | assert apply(5 + a, 5 * a) == 35; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb776.sk: -------------------------------------------------------------------------------- 1 | pragma options "--debug-show-dag"; 2 | 3 | int t = {| 5 | 4 | 3 |}; 4 | 5 | harness void main(int[t] v, int x){ 6 | assert x+x == x*??; 7 | } 8 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb780.sk: -------------------------------------------------------------------------------- 1 | harness void main(int x, int y){ 2 | 3 | int q = ??; 4 | 5 | assert (q + x) / ?? == 1 + x/3; 6 | 7 | 8 | int[5] t = ??; 9 | 10 | assert t[(x+??) % ??] == ((x+2) % 5) + 3; 11 | 12 | 13 | 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb802.sk: -------------------------------------------------------------------------------- 1 | int foo(fun f, T t){ 2 | return f(g(t)); 3 | } 4 | 5 | T g(T i){ 6 | return i; 7 | } 8 | 9 | harness void main(int q){ 10 | int gg(int x){ 11 | return x + 1; 12 | } 13 | assert foo(gg, q)==q+??; 14 | } 15 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb819.sk: -------------------------------------------------------------------------------- 1 | package YY{ 2 | adt A { 3 | B {} 4 | } 5 | harness void main(){ 6 | B@YY a = new B(); 7 | assert($(A) === a); 8 | } 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb820.sk: -------------------------------------------------------------------------------- 1 | // Testing that local variables work with statement assignments 2 | 3 | harness void main() { 4 | int x; 5 | int y; 6 | int z; 7 | 8 | $(int) = 5; 9 | 10 | assert y == 5; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb836.sk: -------------------------------------------------------------------------------- 1 | 2 | int callit(fun fnz) { return hi(fnz(0)); } 3 | 4 | int hi(int x) { return x; } 5 | 6 | harness void test1(int n) { 7 | assume n == 5; 8 | int fn(int i) { return n; } 9 | 10 | assert callit(fn) == 5; 11 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb837.sk: -------------------------------------------------------------------------------- 1 | harness void main(int i){ 2 | int[5] T; 3 | int[7] Q; 4 | int[8][2] P; 5 | 6 | T[4] = 8; 7 | 8 | assert (?? ? T : (?? ? Q : P[??]))[ ?? ? i : ?? ] == 8; 9 | 10 | 11 | 12 | 13 | 14 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb838.sk: -------------------------------------------------------------------------------- 1 | pragma options "--debug-show-dag"; 2 | 3 | int foo(int x); 4 | 5 | harness void main(int x, int y, int z){ 6 | assume x == z; 7 | assume foo(z+x) > ??; 8 | assume foo(y) > ??; 9 | if(foo(2*x) > 5){ 10 | assert foo(x+x) + foo(y) > 6; 11 | } 12 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb842.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | harness void main(int t, int[t + 2] x){ 4 | assume t < 5; 5 | int[2+{| 1 | t | 3 |}] y = x; 6 | y[0] = 0; 7 | x[??] = ??; 8 | assert y == x; 9 | 10 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb846.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | T fst(T x, T y){ 4 | return x; 5 | } 6 | 7 | 8 | harness void main(int n, int[n] a){ 9 | assume n < 8; 10 | int[n] b; 11 | 12 | assert fst(a,b) == a; 13 | assert fst(4,5) == ??; 14 | 15 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb855.sk: -------------------------------------------------------------------------------- 1 | int f(int x); 2 | 3 | harness void main(int x){ 4 | 5 | int t = (f(x) == f(x-1) ? f(x) : f(x-1)); 6 | assert t == f(x-??); 7 | 8 | } 9 | 10 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb859.sk: -------------------------------------------------------------------------------- 1 | 2 | pragma options "--fe-fpencoding TO_BACKEND -p lowering --debug-show-dag"; 3 | 4 | include "math.skh"; 5 | 6 | harness void main(){ 7 | float t = {| Pi() | Pi()/2.0 | Pi() * 2.0 |}; 8 | assert sin(t) == 0.5 + 0.5; 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb864.sk: -------------------------------------------------------------------------------- 1 | pragma options "--fe-fpencoding AS_FIXPOINT --bnd-unroll-amnt 35 --bnd-cbits 7"; 2 | 3 | int compare_float_float(float x, float y) { return (x < y) ? -1 : ((x == y) ? 0 : 1); } 4 | harness void mn() { 5 | assert compare_float_float((float)3.1415, (float)3.1415) == 0; 6 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb891.sk: -------------------------------------------------------------------------------- 1 | 2 | include "stack.skh"; 3 | 4 | harness void main(int x){ 5 | Stack stack = new Nil(); 6 | stack = push(stack, x); 7 | assert peek(stack) == x; 8 | pop(stack); 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb892.sk: -------------------------------------------------------------------------------- 1 | 2 | include "stack.skh"; 3 | 4 | harness void main(int x){ 5 | Stack stack = Empty(); 6 | stack = push(stack, x); 7 | assert peek(stack) == x; 8 | pop(stack); 9 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb893.sk: -------------------------------------------------------------------------------- 1 | 2 | include "stack.skh"; 3 | 4 | harness void main(int x){ 5 | Stack stack = Empty(); 6 | 7 | void action(){ 8 | stack = push(stack, x); 9 | assert peek(stack) == x; 10 | } 11 | 12 | action(); 13 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb896.data: -------------------------------------------------------------------------------- 1 | 2 { {5,15}, {2, 6}} 2 | 2 { {2,6}, {1, 3}} -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb896.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | int foo(int n){ 4 | return n * ??; 5 | } 6 | 7 | @FromFile("miniTestb896.data") 8 | harness void main(int n, int[2][n] in){ 9 | for(int i=0; i lst = add(add(add(empty(), 1), 2), 3); 9 | 10 | assert head(lst) == ??; 11 | 12 | } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb901.data: -------------------------------------------------------------------------------- 1 | 2 { {5.0, 15.0 }, {2.5, 7.5 }} 2 | 3 { {2.33 , 6.99 }, {1.33 , 3.99 }, {-1.33, -3.99}} -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb908.sk: -------------------------------------------------------------------------------- 1 | include "miniTestb908_p1.skh"; 2 | include "miniTestb908_p2.skh"; 3 | harness void main() { f1(); f2(); } 4 | -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb908_p1.skh: -------------------------------------------------------------------------------- 1 | package p1; 2 | void func() { if(??) { f3(); } } 3 | void f1 () { func(); } 4 | void f3() { func(); } -------------------------------------------------------------------------------- /src/test/sk/seq/miniTestb908_p2.skh: -------------------------------------------------------------------------------- 1 | package p2; 2 | void func() { ; } 3 | void f2 () { func(); } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest01.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 32"; 2 | 3 | int getLen([int n], int[n] x, int[n] y){ 4 | return n; 5 | } 6 | 7 | harness void main(int n, int[n] x){ 8 | int[n+23-??] y = x; 9 | assert getLen(x, y[0::foo(n)]) == n+(??-??); // TypeError 10 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest07.sk: -------------------------------------------------------------------------------- 1 | 2 | int foo(){ 3 | return 0; 4 | } 5 | 6 | harness void main(){ 7 | assert 2.0 + foo() > 0.0; // TypeError 8 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest11.sk: -------------------------------------------------------------------------------- 1 | 2 | struct Foo{ 3 | int x; 4 | } 5 | 6 | struct Moo{ 7 | int y; 8 | } 9 | 10 | harness void main(int i){ 11 | Foo[3] f = {new Foo(), new Moo(), new Foo()}; // TypeError mixed types in array init. 12 | assert f[0].x == 0; 13 | 14 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest14.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | struct F{ 4 | int n; 5 | int[n] x; 6 | } 7 | 8 | struct G{ 9 | int y; 10 | } 11 | 12 | harness void main(int i){ 13 | F f = new F(n=5, x=i); 14 | G g = new G(y=f.x); //TypeError 15 | } 16 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest15.sk: -------------------------------------------------------------------------------- 1 | pragma options "--fe-fpencoding AS_FIXPOINT"; 2 | 3 | 4 | harness void main(int i, int j){ 5 | double x = (double) i; 6 | double y = 0; //TypeError 7 | assert x >= y; 8 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest20.sk: -------------------------------------------------------------------------------- 1 | pragma options "--bnd-unroll-amnt 32"; 2 | 3 | 4 | harness void foo(int i){ 5 | int[i] x = 0; 6 | ++i; //TypeError 7 | 8 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest24.sk: -------------------------------------------------------------------------------- 1 | 2 | void foo([int n, int m], int[n] x, int[m] y){ 3 | 4 | } 5 | 6 | harness void moo(int i, int j){ 7 | int[i] x; 8 | int[j] y; 9 | foo(i, x, y); //TypeError 10 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest25.sk: -------------------------------------------------------------------------------- 1 | 2 | void foo([int n], int[n] x, int[n] y){ 3 | 4 | } 5 | 6 | harness void moo(int i, int j){ 7 | int[i] x; 8 | int[j] y; 9 | foo(x, y); //TypeError 10 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest26.sk: -------------------------------------------------------------------------------- 1 | 2 | int foo(){ 3 | 4 | } 5 | 6 | harness void bar(){ 7 | fun f = foo; // TypeError 8 | 9 | 10 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest29.sk: -------------------------------------------------------------------------------- 1 | 2 | struct Bar{ 3 | int x; 4 | } 5 | 6 | Bar spec(int x){ 7 | return new Bar(x=x); 8 | } 9 | 10 | Bar sketch(int x) implements spec{ //TypeError 11 | Bar t = new Bar(x=x); 12 | return new Bar(x=x+??); 13 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest30.sk: -------------------------------------------------------------------------------- 1 | 2 | struct Bar{ 3 | int x; 4 | } 5 | 6 | Bar spec(int x){ 7 | return |Bar|(x=x+3); 8 | } 9 | 10 | |Bar| sketch(int x) implements spec{ //TypeError 11 | Bar t = new Bar(x=x); 12 | return |Bar|(x=x+??); 13 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest31.sk: -------------------------------------------------------------------------------- 1 | package main; 2 | include "typeTest31a.skh"; 3 | 4 | struct car{ 5 | bit x; 6 | } 7 | 8 | struct bus{ 9 | int y; 10 | } 11 | 12 | int sk(|car| x) implements spec{ // TypeError 13 | return x.x? 5 : 7; 14 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest31a.skh: -------------------------------------------------------------------------------- 1 | package a; 2 | 3 | struct car{ 4 | int b; 5 | int m; 6 | } 7 | 8 | struct bus{ 9 | int m; 10 | } 11 | 12 | int spec(|car| x){ 13 | return x.m; 14 | } 15 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest32.sk: -------------------------------------------------------------------------------- 1 | package main; 2 | 3 | struct car{ 4 | bit x; 5 | } 6 | 7 | struct bus{ 8 | int y; 9 | } 10 | 11 | int sk(|car| x) implements spec{ // TypeError 12 | return x.x? 5 : 7; 13 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest33.sk: -------------------------------------------------------------------------------- 1 | 2 | struct car{ 3 | bit x; 4 | } 5 | 6 | int spec(car[5] x){ 7 | car y = new car(x=0); 8 | return x[0].x; 9 | } 10 | 11 | int sk(car[5] x) implements spec{ //TypeError 12 | car y = new car(x=1); 13 | return x[1].x; 14 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest38.sk: -------------------------------------------------------------------------------- 1 | 2 | void foo(int x, int y); 3 | 4 | harness void tester1(){ 5 | int x= ??; 6 | int t; 7 | if(x>7){ 8 | t = 5 9 | }else{ // TypeError parser will fail here. 10 | t = 15; 11 | } 12 | foo(t, x); 13 | minimize(x + t); 14 | 15 | } 16 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest39.sk: -------------------------------------------------------------------------------- 1 | foobaz bad; // TypeError 2 | 3 | harness void main(int x){ 4 | 5 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest40.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | int[5] x = {1,2, 3, 4, 5, 6, 7}; // TypeError rhs is too long. 4 | 5 | harness void main(){ 6 | assert x[3] == 0; 7 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest41.sk: -------------------------------------------------------------------------------- 1 | 2 | harness void main(){ 3 | 4 | int[4] x = (int[4]){5, 6, "test"}; 5 | 6 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest42.sk: -------------------------------------------------------------------------------- 1 | struct foo{ 2 | int x; 3 | int y; 4 | int x; 5 | } 6 | 7 | harness void main(){ 8 | foo f = new foo(); 9 | 10 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest47.sk: -------------------------------------------------------------------------------- 1 | //Same struct names 2 | struct Tree{} 3 | struct Tree extends Tree{} // TypeError 4 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest55.sk: -------------------------------------------------------------------------------- 1 | //Semantic check failed error 2 | struct Leaf extends Tree{ //TypeError 3 | int value; 4 | } //Parent struct must be defined 5 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest59.sk: -------------------------------------------------------------------------------- 1 | //Semantic check failed - same field in parent and child 2 | struct Tree{ //TypeError 3 | int value; 4 | } 5 | struct Leaf extends Tree{ // TypeError 6 | int value; 7 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest61.sk: -------------------------------------------------------------------------------- 1 | //Semantic check failed - struct representing a parent cannot be instantiated. 2 | struct Tree{} 3 | struct Leaf extends Tree{} 4 | 5 | harness void test(){ 6 | Tree tree = new Tree(); // TypeError tree is abstract and cannot be instantiated. 7 | } 8 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest65.sk: -------------------------------------------------------------------------------- 1 | 2 | int foo(){ 3 | 4 | } 5 | 6 | harness int foo(int w){ 7 | foo(); // TypeError no overloading allowed yet. 8 | 9 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest66.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | harness bit bug2() { 4 | int[-1] bad; // TypeError negative indexes not allowed. 5 | int x = bad[0]; 6 | return x > 0; 7 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest67.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | harness bit bug2(int sz) { 4 | 5 | int[sz - 3] bad; // TypeError negative indexes not allowed. 6 | int x = bad[0]; 7 | return x > 0; 8 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest68.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | harness bit bug2(int sz) { 4 | 5 | int[sz - 3][7][13] bad; // TypeError negative indexes not allowed. 6 | int[sz - 3][7] x = bad[0]; 7 | return x[0][0] > 0; 8 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest69.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | harness bit bug2(int sz) { 4 | 5 | int[12] x = 0; 6 | return x > 0; // TypeError 7 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest71.sk: -------------------------------------------------------------------------------- 1 | //does not work 2 | harness void main(){ 3 | int x = 5; 4 | int[1] y = x.{int}; //TypeError 5 | 6 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest72.sk: -------------------------------------------------------------------------------- 1 | //Doesn't work 2 | //right-hand side of assignment must be promotable to left-hand side's type 3 | struct A{ 4 | int x; 5 | } 6 | 7 | 8 | harness void main(){ 9 | A a = new A(); 10 | bit[3] arr = a.{int}; // TypeError 11 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest75.sk: -------------------------------------------------------------------------------- 1 | struct A { 2 | int x; 3 | } 4 | 5 | 6 | int foo (A a, B b) { // TypeError 7 | // return a.x + b.y; 8 | return a.x; 9 | } 10 | 11 | harness void main() { 12 | A x = new A(x = 1); 13 | 14 | assert foo(x, null) == 1; 15 | } 16 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest82.sk: -------------------------------------------------------------------------------- 1 | struct Car { //TypeError 2 | int id; 3 | fun gear; // NullPointerException 4 | } 5 | 6 | harness void main() { 7 | assert true; 8 | } 9 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest83.sk: -------------------------------------------------------------------------------- 1 | harness void main() { 2 | fun1@name(); // TypeError 3 | assert true; 4 | } 5 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest84.sk: -------------------------------------------------------------------------------- 1 | void foo(int a, int b){ 2 | 3 | 4 | } 5 | 6 | 7 | harness void main(int x, int y){ 8 | 9 | foo(a=x, b=y); // TypeError named parameters to functions not supported yet. 10 | 11 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest85.sk: -------------------------------------------------------------------------------- 1 | struct Bar {} 2 | 3 | void foo(ref Bar b){ 4 | 5 | 6 | } 7 | 8 | harness void main(int x){ 9 | 10 | foo(new Bar()); // TypeError 11 | 12 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest88.sk: -------------------------------------------------------------------------------- 1 | struct A{} 2 | struct B extends A{ int x; int[x] a;} 3 | struct C extends A{ int y; int[y] a;} 4 | 5 | harness void main(){ 6 | A a = new ??(x=2, y=3, a = ??); // TypeError 7 | 8 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest93.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | @inrange("y:-10:-5") 5 | harness void main(int x){ // TypeError 6 | int t = x + ??; 7 | assert t < 0; 8 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest94.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | @inrange("y:-10") 5 | harness void main(int x){ // TypeError 6 | int t = x + ??; 7 | assert t < 0; 8 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest95.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | @inrange("y:a:b") 5 | harness void main(int x){ // TypeError 6 | int t = x + ??; 7 | assert t < 0; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTest96.sk: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | @inrange("y:10:20") 5 | harness void main(int x, int[x] y){ // TypeError 6 | int t = x + ??; 7 | assert t < 0; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb104.sk: -------------------------------------------------------------------------------- 1 | // Assigning a lambda to an int. 2 | 3 | harness void main(int x){ 4 | int a = (x) -> x + 1; //TypeError shadowing, type mismatch 5 | 6 | assert a(4) == 5; 7 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb106.sk: -------------------------------------------------------------------------------- 1 | // Cannot return type fun 2 | 3 | fun error() { 4 | fun f = () -> 5; 5 | 6 | return f; //TypeError 7 | } 8 | 9 | harness void main() { 10 | error(); 11 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb107.sk: -------------------------------------------------------------------------------- 1 | // Cannot return lambda 2 | 3 | fun error() { 4 | return () -> 5; //TypeError 5 | } 6 | 7 | harness void main() { 8 | assert error() == 5; 9 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb108.sk: -------------------------------------------------------------------------------- 1 | // Cannot have statements in lambda expression 2 | 3 | harness void main() { 4 | int t = 3; 5 | 6 | 7 | 8 | fun f = (x) -> t + x++; //TypeError 9 | 10 | assert f(3) == 4; 11 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb112.sk: -------------------------------------------------------------------------------- 1 | // Cannot have statements in lambda expression 2 | 3 | harness void main() { 4 | int t = 3; 5 | 6 | int test() { 7 | fun f = (x) -> t + x++; //TypeError 8 | 9 | return f(3); 10 | } 11 | 12 | assert test() == 6; 13 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb113.sk: -------------------------------------------------------------------------------- 1 | // Cannot have statements in lambda expression 2 | 3 | harness void main() { 4 | int t = 3; 5 | 6 | int test() { 7 | fun f = () -> t = t + 5; //TypeError does not parse. 8 | 9 | return f(); 10 | } 11 | 12 | assert test() == 8; 13 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb119.sk: -------------------------------------------------------------------------------- 1 | struct scalar { bit supp; int val; } 2 | 3 | 4 | 5 | harness void test2(int n, int i, int j) { 6 | assert func(|scalar|(supp=0,val=0)); //TypeError 7 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb122.sk: -------------------------------------------------------------------------------- 1 | bit foo(bit[3] x, bit[3] y) implements fooSK{ 2 | bit z = x ==y; 3 | bit w = x+y == x; 4 | 5 | return (x == y? z - 1 + ??: w - 1 + ??); //TypeError. 6 | } 7 | 8 | bit fooSK(bit[3] x, bit[3] y){ 9 | return (x == y? x==y:x+y == x); 10 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb129.sk: -------------------------------------------------------------------------------- 1 | struct List 2 | { 3 | int size; 4 | int [size] contents; 5 | } 6 | 7 | harness void sketch() { 8 | List l1 = new List(); 9 | l1.size = 1; //TypeError 10 | } 11 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb130.sk: -------------------------------------------------------------------------------- 1 | 2 | harness void main(){ 3 | int y = x + 2; //TypeError 4 | 5 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb131.sk: -------------------------------------------------------------------------------- 1 | struct scalar { bit supp; int val; } 2 | 3 | bit funa(|scalar| a) { return (a.vak + 0);} //TypeError 4 | 5 | 6 | harness void test1(int n, int i, int j) { 7 | assert funa(|scalar|(supp=0,val=0)); 8 | } 9 | 10 | -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb135.sk: -------------------------------------------------------------------------------- 1 | 2 | package A{ 3 | int f(int x); 4 | } 5 | 6 | package B{ 7 | int f(int x); 8 | 9 | harness void main(int x){ 10 | assert f@B(x) == f@A(x); // TypeError This should fail because the two fs are different functions. 11 | } 12 | } -------------------------------------------------------------------------------- /src/test/sk/typechecking/typeTestb136.sk: -------------------------------------------------------------------------------- 1 | 2 | struct s { 3 | int x; 4 | int x; 5 | } 6 | 7 | harness void main () { 8 | assert true; 9 | } 10 | --------------------------------------------------------------------------------