-
Notifications
You must be signed in to change notification settings - Fork 6
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
[ test, perf ] Add couple of kinda-performance tests
- Loading branch information
Showing
14 changed files
with
592 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,299 @@ | ||
------------------- | ||
|
||
extension (lsbhzmuum: Int) | ||
def f(g: Boolean, zhdjsjn: Boolean, bzxbnt: Int, kcykprmz: Boolean, j: Int, pofpamn: Int): Unit = { | ||
def bjzxbceo(vr: Boolean, aqh: Boolean, vgpeorkzyw: Boolean, tjwddp: Int, vaezbrut: Boolean) = | ||
extension (viradza: Boolean) | ||
def ochswyeoo(urqplbpag: Boolean, kxswdyvkau: Boolean, dxod: Boolean): Boolean = { | ||
Console.println((7.+(tjwddp)).+(tjwddp + 7)) | ||
val eqibjfxxwk = 3 | ||
if (tjwddp.==(7)) && (0 < (7.+(7))) then { | ||
val otmkdghq = (7 + tjwddp).+(tjwddp + (6.+(3))) | ||
|
||
} else { | ||
val ypll = (dnwfdiifst: Int, kqedtsy: Int) => | ||
false | ||
|
||
} | ||
Console.println((tjwddp.+(0)).+(0 + tjwddp)) | ||
true || (3 == (tjwddp.+(3))) | ||
} : Boolean | ||
val hb = () => { | ||
extension (seg: Int) | ||
def naqy(lfn: Boolean): Unit = { | ||
if vr.ochswyeoo(3.<=(pofpamn), vgpeorkzyw, vgpeorkzyw.&&(vr && vr)) then { | ||
|
||
} else { | ||
|
||
} | ||
if vgpeorkzyw then { | ||
|
||
} | ||
|
||
} | ||
if true.ochswyeoo(aqh.||(true), vr || aqh, kcykprmz.ochswyeoo(true, aqh, vr)) then { | ||
(j.+(j.+(j))).naqy((j + 7) == 1) | ||
|
||
} else { | ||
val tuihc = (p: Boolean) => | ||
(pofpamn.+(2)) + (6 + 4) | ||
|
||
} | ||
5 naqy false | ||
|
||
} : Unit | ||
if vgpeorkzyw then { | ||
hb() | ||
hb() | ||
|
||
} else { | ||
var oqj: Boolean = true.ochswyeoo(0 == j, true || false, false) | ||
if false.ochswyeoo(tjwddp.<=(pofpamn), pofpamn == j, vr.ochswyeoo(vgpeorkzyw, vr, false)) then { | ||
|
||
} else { | ||
|
||
} | ||
|
||
} | ||
val omu = (hufz: Int) => { | ||
extension (y: Boolean) def zqh(fzjuxude: Boolean): Int = { 2 + 7 } | ||
|
||
} | ||
extension (k: Boolean) | ||
def gwdekh(qjwjul: Boolean, gxeqlbtyx: Boolean, xdkbf: Int, lrxkafuei: Boolean) = { (tjwddp + tjwddp).+(tjwddp + (7.+(tjwddp))) } | ||
|
||
if kcykprmz then | ||
val kbabzad = (7.+(2)).+(pofpamn + (bzxbnt.+(bzxbnt))) | ||
bjzxbceo(false, false.&&(false), false.&&(!(kcykprmz)), 1.+(1 + kbabzad), !(1 == 2)) | ||
val nq = (cmyobf: Boolean, huqexo: Boolean, zqjoqhc: Int, npsdrjl: Boolean) => { | ||
extension (cwmxl: Boolean) def rgoh(rxrn: Boolean, gwlvzwkq: Boolean, dswokhsap: Boolean, cxalh: Int, b: Boolean, qmrj: Int): Unit = { } | ||
|
||
} : Unit | ||
if (bzxbnt.==(lsbhzmuum)) || (g && (zhdjsjn && false)) then | ||
{} | ||
|
||
else | ||
bjzxbceo(zhdjsjn, zhdjsjn, false.||(true), 5, g || (true && (!(g)))) | ||
if (lsbhzmuum + lsbhzmuum).==(2 + (lsbhzmuum.+(5))) then { | ||
|
||
} else { | ||
val slhuhvgxj = (eysb: Int, bzvphqjmab: Boolean, rnkab: Int, gwjkn: Boolean) => { | ||
val fbp = (obe: Boolean, l: Boolean, ohvxpkk: Int) => { } : Unit | ||
false.||(kcykprmz.&&(bzvphqjmab)) | ||
} : Boolean | ||
bjzxbceo(zhdjsjn, true, 0.==(6), lsbhzmuum.+(lsbhzmuum.+(lsbhzmuum)), slhuhvgxj(6, false, 4, pofpamn == lsbhzmuum)) | ||
|
||
} | ||
val zm = g | ||
val v = () => { lsbhzmuum.+(lsbhzmuum.+(2.+(bzxbnt))) } | ||
|
||
val isxqgqhpn = 3 | ||
if lsbhzmuum == (7.+(pofpamn)) then { | ||
if (!(true)) || ((!(kcykprmz)) && g) then | ||
{} | ||
else | ||
var ncdficbyg = (0 + lsbhzmuum).+(3.+(6.+(2))) | ||
|
||
|
||
} else { | ||
val kopmjkfxqc = (uhkjm: Boolean, zpucu: Boolean, oywl: Boolean, pm: Boolean, ecl: Int, bgwwsmfgc: Int) => { | ||
extension (vfc: Int) def mg(rhpvtn: Int, gkzppygn: Boolean, fynouiswxi: Boolean): Int = { (ecl.+(vfc)) + (ecl.+(4 + 7)) } : Int | ||
|
||
} : Unit | ||
bjzxbceo(zhdjsjn, lsbhzmuum.==(3), 1 == 3, 4.+(4.+(3)), (bzxbnt + 6).==(6.+(4))) | ||
|
||
} | ||
|
||
} | ||
|
||
@main | ||
def nnrdtjkx(): Unit = { | ||
if (6 + 4) == 3 then { | ||
if false then | ||
3.f(true, !(false), 0 + 6, true, 1 + (4 + 0), 6.+(0.+(7))) | ||
6.f(true, !(true), 2 + 1, 6.<=(4), 5 + (7.+(1)), 7.+(4 + 3)) | ||
var ltszwkd = (5.+(5)).+(4 + (1 + 1)) | ||
if (ltszwkd + ltszwkd).==(ltszwkd + 4) then { | ||
|
||
} | ||
|
||
else | ||
def yopcgm(kberik: Int, sshmtadbj: Boolean, wzmrcfnc: Int, i: Int, gxnzfx: Boolean, txuelhidi: Int) = | ||
def entrdwrxol(qrkjobhkoz: Int, nepwgyzn: Int, uy: Boolean) = | ||
5.f(sshmtadbj, true, i, !(true), 6 + wzmrcfnc, 4.+(3)) | ||
extension (hide: Boolean) | ||
def xbjtxt(zpljmsul: Int, t: Boolean, qdicfwb: Boolean, vxhyd: Boolean, ebqobvrg: Int): Unit = | ||
{} | ||
(sshmtadbj && true) && (true || false) | ||
if sshmtadbj then { | ||
|
||
} else { | ||
def quwdhtki() = | ||
entrdwrxol(wzmrcfnc.+(kberik), kberik + 1, entrdwrxol(kberik, kberik, sshmtadbj.||(true))) | ||
|
||
} | ||
kberik.f(true, false, 4, false || false, i + (txuelhidi.+(7)), (1.+(kberik)).+(kberik.+(0))) | ||
|
||
val wvw: Int = (0.+(0)).+(4) | ||
var vhnp: Int = 7 | ||
vhnp = (3 + 2) + 5 | ||
|
||
val xfb = (fvzwxya: Boolean, mqemczi: Boolean, wkfxa: Boolean, wv: Boolean, cti: Boolean, nxcsam: Int) => { | ||
var ohssei: Boolean = (nxcsam.+(3)).==(nxcsam.+(nxcsam.+(2))) | ||
ohssei = mqemczi | ||
5.f(true, !(ohssei), 0.+(nxcsam), nxcsam == nxcsam, 0 + (nxcsam.+(nxcsam)), 1) | ||
|
||
} : Unit | ||
val igu = (5 + 3) + (1.+(3.+(4))) | ||
|
||
} else { | ||
if (5.+(3)) == (6.+(6.+(5))) then | ||
if (true || (!(true))).&&(6 <= 4) then { | ||
if (4 <= 7).&&(7 == 6) then | ||
6.f(true, false, 5 + 7, false && (!(true)), 2 + (2.+(3)), (5 + 2).+(4)) | ||
val rsebaxwtd: Int = (3 + 5).+(1 + 6) | ||
|
||
else | ||
val dfnclwya: Int = 0 + (7.+(6)) | ||
|
||
if true then | ||
0.f(true, false, 5 + 2, 2.==(7), 2 + (4.+(7)), (1 + 1).+(7 + 2)) | ||
|
||
else | ||
val bxcaf = !(4 <= (1.+(3))) | ||
|
||
|
||
} else { | ||
var rrdv = 3.+(6 + (1.+(1))) | ||
if (!(!(false))).&&((!(true)).&&(false.&&(false))) then { | ||
extension (whbsqvi: Boolean) def xcsjakiieb(qdxfpf: Boolean, ghix: Boolean): Unit = { } : Unit | ||
|
||
} else { | ||
rrdv = (rrdv + 7) + (1 + rrdv) | ||
|
||
} | ||
rrdv.f(false, !(true), rrdv, false, rrdv, rrdv.+(rrdv)) | ||
|
||
} | ||
extension (ebedfdsy: Boolean) | ||
def ktqlcles(aytjcbxl: Boolean, ycvic: Boolean, kkdwd: Boolean, hbwucxlwb: Int, nopwim: Boolean, wy: Int) = { | ||
def fep(wcmeyqttd: Boolean, hmnimcmdmb: Boolean, oqc: Int, qc: Boolean, gglip: Boolean, fhecmkilwq: Int) = { | ||
if !((!(true)).&&(!(false))) then { | ||
|
||
} | ||
(wy + 4) + (wy + (7.+(5))) | ||
} | ||
if (2.+(6)) < (1 + (wy.+(hbwucxlwb))) then { | ||
|
||
} | ||
hbwucxlwb.==(6) | ||
} | ||
if true || true then | ||
{} | ||
else | ||
0.f(false, false, 1.+(3), true.&&(true), 4 + (5 + 6), 4.+(5 + 5)) | ||
|
||
|
||
else | ||
extension (ztqxsw: Boolean) | ||
def dixlzn(vkdgl: Boolean): Int = | ||
def hyh(yr: Int) = { | ||
yr.f(ztqxsw, !(false), 4 + yr, true.||(!(ztqxsw)), yr, (1.+(yr)) + (yr.+(yr))) | ||
def t(ycfvjun: Boolean, x: Int, gdcgpkzlp: Int, pj: Int, jqqmg: Boolean, iy: Boolean, ycpwl: Int) = { yr } | ||
(3 + yr) + (yr.+(1)) | ||
} | ||
7.f(ztqxsw, false, hyh(6), false && ztqxsw, hyh(3) + 6, (0.+(6)).+(hyh(hyh(5)))) | ||
var dnzjab: Boolean = (2.<(hyh(5))) || (ztqxsw || (ztqxsw.||(ztqxsw))) | ||
(4.+(3)) + 0 | ||
if (false.&&(false)) || (true || false) then { | ||
if (3 == 2) || (true || (5 < 6)) then { | ||
|
||
} else { | ||
if (1 == 6) && (false || (4 == 0)) then { | ||
|
||
} else { | ||
|
||
} | ||
|
||
} | ||
0.f(true, true, 2.+(5), 7.==(6), 5.+(false.dixlzn(true)), false.dixlzn(true.||(true))) | ||
|
||
} else { | ||
val xikz = (6 < 0).dixlzn(2.==(true dixlzn true)) | ||
var alcsccds = xikz.+(xikz + (true dixlzn true)) | ||
|
||
} | ||
2.f(true, false, false dixlzn true, 7.==(4), true.dixlzn(4 == 1), (true.||(true)) dixlzn (0.<(3))) | ||
if (4.==(6)) || (3.<=(5)) then { | ||
|
||
} | ||
|
||
extension (c: Boolean) | ||
def vimqhhecmj(pciwteqyeg: Boolean, i: Int): Unit = { | ||
extension (fmur: Boolean) | ||
def gm(catxxjb: Boolean) = | ||
{} | ||
|
||
} : Unit | ||
if (7 + 4).<=(6.+(1.+(6))) then | ||
if 7.==(0 + (6 + 0)) then { | ||
|
||
} else { | ||
3.f(true, true, 1.+(3), 1 < 4, 3 + 5, (7.+(3)) + 2) | ||
|
||
} | ||
val xje = (vvucin: Boolean, ykx: Boolean) => { {} } : Unit | ||
|
||
else | ||
def cpebujzqsq(tx: Boolean, gmowwc: Boolean, liioogmgn: Boolean, gstsfcyy: Boolean, cidva: Boolean, dncqpxsmyk: Boolean): Int = { | ||
7.f(true, true, 3 + 0, 3.==(6), 3 + 1, 4) | ||
(6.+(5)) + (0 + (5 + 6)) | ||
} | ||
var qkufrhxr: Int = cpebujzqsq(true, false, true, 6 == 6, true || true, 2 == (5.+(6))) | ||
|
||
if (0 < 7).&&(6.==(5)) then { | ||
0.f(false, true, 1 + 0, 2 < 1, 7.+(2.+(7)), (4 + 6) + (6.+(2))) | ||
|
||
} | ||
if (3.<(1)).&&(true) then { | ||
|
||
} else { | ||
|
||
} | ||
|
||
} | ||
extension (vh: Boolean) | ||
def aeiurowfu(jwwzhjw: Boolean, ibz: Boolean, yqncdnqvpn: Int) = { | ||
if false then | ||
var rtikn: Int = (yqncdnqvpn.+(3)).+(5.+(7)) | ||
|
||
else | ||
if (true.&&(!(vh))).||(yqncdnqvpn <= (3.+(2))) then | ||
var eayrlw = 2 | ||
|
||
else | ||
if (yqncdnqvpn.==(0)) || (!(!(ibz))) then | ||
0.f(vh, !(false), yqncdnqvpn.+(yqncdnqvpn), true || false, 2, 4 + yqncdnqvpn) | ||
|
||
else | ||
if ibz || (true.&&(yqncdnqvpn == 2)) then | ||
{} | ||
else | ||
{} | ||
|
||
7.f(vh, ibz, 0, false, 4.+(yqncdnqvpn.+(2)), 2) | ||
|
||
6.f(true, !(jwwzhjw), 6.+(1), yqncdnqvpn == yqncdnqvpn, yqncdnqvpn + yqncdnqvpn, (1 + yqncdnqvpn).+(yqncdnqvpn)) | ||
val ej = (e: Int, csduuukao: Int, icultio: Boolean) => { } : Unit | ||
|
||
var zdxgniq: Int = (yqncdnqvpn.+(2)) + (yqncdnqvpn + yqncdnqvpn) | ||
zdxgniq = yqncdnqvpn + (yqncdnqvpn.+(yqncdnqvpn + 4)) | ||
var op = (yqncdnqvpn.+(0)) + yqncdnqvpn | ||
|
||
} | ||
2.f(true, false, 0.+(4), 7 == 2, 6.+(1.+(5)), 7.+(3.+(3))) | ||
val krpizyyqcz = (m: Int, hae: Boolean, g: Boolean, qlbexdotf: Int) => { g } | ||
true.aeiurowfu(2.==(4), krpizyyqcz(2, true, true, 2), 7 + (1.+(5))) | ||
val qqhmi = krpizyyqcz(5, false || false, false, 3.+(2)) | ||
|
||
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,6 @@ | ||
rm -rf build | ||
|
||
flock "$1" pack -q install-deps pil-fun && \ | ||
pack run pil-fun scala3 --seed 0,3 --tests 1 --model-fuel 6 | ||
|
||
rm -rf build |
Oops, something went wrong.