From 9e75a6b1268ce66f823796bf440bf155979d1aa4 Mon Sep 17 00:00:00 2001 From: Alex Fischman Date: Mon, 2 Dec 2024 13:33:18 -0800 Subject: [PATCH 01/10] cargo init --- .gitignore | 1 + Cargo.toml | 6 ++++++ src/main.rs | 3 +++ 3 files changed, 10 insertions(+) create mode 100644 .gitignore create mode 100644 Cargo.toml create mode 100644 src/main.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ea8c4bf --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/target diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..74a1d06 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "egglog-experimental" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..e7a11a9 --- /dev/null +++ b/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + println!("Hello, world!"); +} From 7aa521fba978bff29e69eeef54081d67f7e11bf1 Mon Sep 17 00:00:00 2001 From: Alex Fischman Date: Mon, 2 Dec 2024 13:36:09 -0800 Subject: [PATCH 02/10] Create Makefile --- Cargo.lock | 1334 ++++++++++++++++++++++++++++++++++++++++++++++++++++ Cargo.toml | 1 + Makefile | 18 + 3 files changed, 1353 insertions(+) create mode 100644 Cargo.lock create mode 100644 Makefile diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..8e3c729 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,1334 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "ahash" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" +dependencies = [ + "getrandom", + "once_cell", + "version_check", +] + +[[package]] +name = "ahash" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011" +dependencies = [ + "cfg-if", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "aho-corasick" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +dependencies = [ + "memchr", +] + +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + +[[package]] +name = "anstream" +version = "0.6.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9" + +[[package]] +name = "anstyle-parse" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c" +dependencies = [ + "windows-sys 0.59.0", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125" +dependencies = [ + "anstyle", + "windows-sys 0.59.0", +] + +[[package]] +name = "ascii-canvas" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6" +dependencies = [ + "term", +] + +[[package]] +name = "autocfg" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" + +[[package]] +name = "bit-set" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" + +[[package]] +name = "bitflags" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" + +[[package]] +name = "bitmaps" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "031043d04099746d8db04daf1fa424b2bc8bd69d92b25962dcde24da39ab64a2" +dependencies = [ + "typenum", +] + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "chrono" +version = "0.4.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401" +dependencies = [ + "num-traits", +] + +[[package]] +name = "clap" +version = "4.5.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb3b4b9e5a7c7514dfa52869339ee98b3156b0bfb4e8a77c4ff4babb64b1604f" +dependencies = [ + "clap_builder", + "clap_derive", +] + +[[package]] +name = "clap_builder" +version = "4.5.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b17a95aa67cc7b5ebd32aa5370189aa0d79069ef1c64ce893bd30fb24bff20ec" +dependencies = [ + "anstream", + "anstyle", + "clap_lex", + "strsim", +] + +[[package]] +name = "clap_derive" +version = "4.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn 2.0.90", +] + +[[package]] +name = "clap_lex" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "afb84c814227b90d6895e01398aee0d8033c00e7466aca416fb6a8e0eb19d8a7" + +[[package]] +name = "colorchoice" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990" + +[[package]] +name = "cpufeatures" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16b80225097f2e5ae4e7179dd2266824648f3e2f49d9134d584b76389d31c4c3" +dependencies = [ + "libc", +] + +[[package]] +name = "crunchy" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" + +[[package]] +name = "crypto-common" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", +] + +[[package]] +name = "dirs-next" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1" +dependencies = [ + "cfg-if", + "dirs-sys-next", +] + +[[package]] +name = "dirs-sys-next" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" +dependencies = [ + "libc", + "redox_users", + "winapi", +] + +[[package]] +name = "dot-generator" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0aaac7ada45f71873ebce336491d1c1bc4a7c8042c7cea978168ad59e805b871" +dependencies = [ + "dot-structures", +] + +[[package]] +name = "dot-structures" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "675e35c02a51bb4d4618cb4885b3839ce6d1787c97b664474d9208d074742e20" + +[[package]] +name = "egglog" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e61ae52399232f9baef42e7c9b7c68ae8569fc8812c766859d8cdead28dd8b33" +dependencies = [ + "chrono", + "clap", + "egraph-serialize", + "env_logger", + "generic_symbolic_expressions", + "hashbrown 0.14.5", + "im-rc", + "indexmap", + "instant", + "lalrpop", + "lalrpop-util", + "lazy_static", + "log", + "num-integer", + "num-rational", + "num-traits", + "ordered-float", + "regex", + "rustc-hash", + "serde_json", + "smallvec", + "symbol_table", + "thiserror", +] + +[[package]] +name = "egglog-experimental" +version = "0.1.0" +dependencies = [ + "egglog", +] + +[[package]] +name = "egraph-serialize" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c31c5c0d7f760f9c1c84e21d73dcd3b3ce7a4770c27689f56a0db26e0f3e79ca" +dependencies = [ + "graphviz-rust", + "indexmap", + "once_cell", + "ordered-float", + "serde", + "serde_json", +] + +[[package]] +name = "either" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" + +[[package]] +name = "ena" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d248bdd43ce613d87415282f69b9bb99d947d290b10962dd6c56233312c2ad5" +dependencies = [ + "log", +] + +[[package]] +name = "env_logger" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cd405aab171cb85d6735e5c8d9db038c17d3ca007a4d2c25f337935c3d90580" +dependencies = [ + "humantime", + "is-terminal", + "log", + "regex", + "termcolor", +] + +[[package]] +name = "equivalent" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" + +[[package]] +name = "errno" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d" +dependencies = [ + "libc", + "windows-sys 0.59.0", +] + +[[package]] +name = "fastrand" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "486f806e73c5707928240ddc295403b1b93c96a02038563881c4a2fd84b81ac4" + +[[package]] +name = "fixedbitset" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "generic_symbolic_expressions" +version = "5.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "597eb584fb7cfd1935294fc3608a453fc35a58dfa9da4299c8fd3bc75a4c0b4b" + +[[package]] +name = "getrandom" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "graphviz-rust" +version = "0.6.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27dafd1ac303e0dfb347a3861d9ac440859bab26ec2f534bbceb262ea492a1e0" +dependencies = [ + "dot-generator", + "dot-structures", + "into-attr", + "into-attr-derive", + "pest", + "pest_derive", + "rand", + "tempfile", +] + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" +dependencies = [ + "ahash 0.7.8", +] + +[[package]] +name = "hashbrown" +version = "0.14.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" +dependencies = [ + "ahash 0.8.11", + "allocator-api2", +] + +[[package]] +name = "hashbrown" +version = "0.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "hermit-abi" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc" + +[[package]] +name = "humantime" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" + +[[package]] +name = "im-rc" +version = "15.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af1955a75fa080c677d3972822ec4bad316169ab1cfc6c257a942c2265dbe5fe" +dependencies = [ + "bitmaps", + "rand_core", + "rand_xoshiro", + "sized-chunks", + "typenum", + "version_check", +] + +[[package]] +name = "indexmap" +version = "2.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f" +dependencies = [ + "equivalent", + "hashbrown 0.15.2", + "serde", +] + +[[package]] +name = "instant" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "into-attr" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18b48c537e49a709e678caec3753a7dba6854661a1eaa27675024283b3f8b376" +dependencies = [ + "dot-structures", +] + +[[package]] +name = "into-attr-derive" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecac7c1ae6cd2c6a3a64d1061a8bdc7f52ff62c26a831a2301e54c1b5d70d5b1" +dependencies = [ + "dot-generator", + "dot-structures", + "into-attr", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "is-terminal" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b" +dependencies = [ + "hermit-abi", + "libc", + "windows-sys 0.52.0", +] + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" + +[[package]] +name = "itertools" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674" + +[[package]] +name = "lalrpop" +version = "0.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55cb077ad656299f160924eb2912aa147d7339ea7d69e1b5517326fdcec3c1ca" +dependencies = [ + "ascii-canvas", + "bit-set", + "ena", + "itertools", + "lalrpop-util", + "petgraph", + "pico-args", + "regex", + "regex-syntax", + "string_cache", + "term", + "tiny-keccak", + "unicode-xid", + "walkdir", +] + +[[package]] +name = "lalrpop-util" +version = "0.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "507460a910eb7b32ee961886ff48539633b788a36b65692b95f225b844c82553" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" + +[[package]] +name = "libc" +version = "0.2.167" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09d6582e104315a817dff97f75133544b2e094ee22447d2acf4a74e189ba06fc" + +[[package]] +name = "libredox" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" +dependencies = [ + "bitflags", + "libc", +] + +[[package]] +name = "linux-raw-sys" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" + +[[package]] +name = "lock_api" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17" +dependencies = [ + "autocfg", + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" + +[[package]] +name = "memchr" +version = "2.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" + +[[package]] +name = "new_debug_unreachable" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086" + +[[package]] +name = "num-bigint" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" +dependencies = [ + "num-bigint", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775" + +[[package]] +name = "ordered-float" +version = "3.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1e1c390732d15f1d48471625cd92d154e66db2c56645e29a9cd26f4699f72dc" +dependencies = [ + "num-traits", + "rand", + "serde", +] + +[[package]] +name = "parking_lot" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-targets", +] + +[[package]] +name = "pest" +version = "2.7.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879952a81a83930934cbf1786752d6dedc3b1f29e8f8fb2ad1d0a36f377cf442" +dependencies = [ + "memchr", + "thiserror", + "ucd-trie", +] + +[[package]] +name = "pest_derive" +version = "2.7.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d214365f632b123a47fd913301e14c946c61d1c183ee245fa76eb752e59a02dd" +dependencies = [ + "pest", + "pest_generator", +] + +[[package]] +name = "pest_generator" +version = "2.7.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb55586734301717aea2ac313f50b2eb8f60d2fc3dc01d190eefa2e625f60c4e" +dependencies = [ + "pest", + "pest_meta", + "proc-macro2", + "quote", + "syn 2.0.90", +] + +[[package]] +name = "pest_meta" +version = "2.7.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b75da2a70cf4d9cb76833c990ac9cd3923c9a8905a8929789ce347c84564d03d" +dependencies = [ + "once_cell", + "pest", + "sha2", +] + +[[package]] +name = "petgraph" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db" +dependencies = [ + "fixedbitset", + "indexmap", +] + +[[package]] +name = "phf_shared" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096" +dependencies = [ + "siphasher", +] + +[[package]] +name = "pico-args" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315" + +[[package]] +name = "ppv-lite86" +version = "0.2.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "precomputed-hash" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" + +[[package]] +name = "proc-macro2" +version = "1.0.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", + "serde", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", + "serde", +] + +[[package]] +name = "rand_xoshiro" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa" +dependencies = [ + "rand_core", +] + +[[package]] +name = "redox_syscall" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f" +dependencies = [ + "bitflags", +] + +[[package]] +name = "redox_users" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43" +dependencies = [ + "getrandom", + "libredox", + "thiserror", +] + +[[package]] +name = "regex" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" + +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + +[[package]] +name = "rustix" +version = "0.38.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7f649912bc1495e167a6edee79151c84b1bad49748cb4f1f1167f459f6224f6" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.52.0", +] + +[[package]] +name = "rustversion" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e819f2bc632f285be6d7cd36e25940d45b2391dd6d9b939e79de557f7014248" + +[[package]] +name = "ryu" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "serde" +version = "1.0.215" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.215" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.90", +] + +[[package]] +name = "serde_json" +version = "1.0.133" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377" +dependencies = [ + "indexmap", + "itoa", + "memchr", + "ryu", + "serde", +] + +[[package]] +name = "sha2" +version = "0.10.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "siphasher" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d" + +[[package]] +name = "sized-chunks" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16d69225bde7a69b235da73377861095455d298f2b970996eec25ddbb42b3d1e" +dependencies = [ + "bitmaps", + "typenum", +] + +[[package]] +name = "smallvec" +version = "1.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" + +[[package]] +name = "string_cache" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f91138e76242f575eb1d3b38b4f1362f10d3a43f47d182a5b359af488a02293b" +dependencies = [ + "new_debug_unreachable", + "once_cell", + "parking_lot", + "phf_shared", + "precomputed-hash", +] + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "symbol_table" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "828f672b631c220bf6ea8a1d3b82c7d0fc998e5ba8373383d8604bc1e2a6245a" +dependencies = [ + "ahash 0.7.8", + "hashbrown 0.12.3", +] + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.90" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tempfile" +version = "3.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c" +dependencies = [ + "cfg-if", + "fastrand", + "once_cell", + "rustix", + "windows-sys 0.59.0", +] + +[[package]] +name = "term" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f" +dependencies = [ + "dirs-next", + "rustversion", + "winapi", +] + +[[package]] +name = "termcolor" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.90", +] + +[[package]] +name = "tiny-keccak" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" +dependencies = [ + "crunchy", +] + +[[package]] +name = "typenum" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" + +[[package]] +name = "ucd-trie" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971" + +[[package]] +name = "unicode-ident" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83" + +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" +dependencies = [ + "windows-sys 0.59.0", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "zerocopy" +version = "0.7.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0" +dependencies = [ + "byteorder", + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.7.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.90", +] diff --git a/Cargo.toml b/Cargo.toml index 74a1d06..962c0c2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,3 +4,4 @@ version = "0.1.0" edition = "2021" [dependencies] +egglog = "0.3.0" diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..af6ab7b --- /dev/null +++ b/Makefile @@ -0,0 +1,18 @@ +all: test nits docs + +test: + cargo nextest run --release + # nextest doesn't run doctests, so do it here + cargo test --doc --release + +nits: + @rustup component add clippy + cargo clippy --tests -- -D warnings + @rustup component add rustfmt + cargo fmt --check + +docs: + mkdir -p ${WWW} + cargo doc --no-deps --all-features + touch target/doc/.nojekyll # prevent github from trying to run jekyll + cp -r target/doc ${WWW}/docs From 77bd4cb256c439ade274c402486b5b0fbca3bfa6 Mon Sep 17 00:00:00 2001 From: Alex Fischman Date: Mon, 2 Dec 2024 14:01:13 -0800 Subject: [PATCH 03/10] Add egglog repo tests --- Cargo.lock | 699 +- Cargo.toml | 11 +- Makefile | 2 + src/lib.rs | 1 + tests/antiunify.egg | 26 + tests/array.egg | 77 + tests/bdd.egg | 107 + tests/before-proofs.egg | 32 + tests/bignum.egg | 13 + tests/birewrite.egg | 18 + tests/bitwise.egg | 37 + tests/bool.egg | 39 + tests/calc.egg | 61 + tests/combinators.egg | 102 + tests/combined-nested.egg | 48 + tests/container-rebuild.egg | 80 + tests/cyk.egg | 115 + tests/cykjson.egg | 44 + tests/cykjson_End.csv | 17 + tests/cykjson_Prod.csv | 17 + tests/cykjson_medium_token.csv | 7821 +++++++++++++++++ tests/cykjson_small_token.csv | 801 ++ tests/datatypes.egg | 11 + tests/delete.egg | 6 + tests/eggcc-extraction.egg | 1711 ++++ tests/eqsat-basic-multiset.egg | 124 + tests/eqsat-basic.egg | 25 + tests/eqsolve.egg | 45 + tests/f64.egg | 13 + .../repro-containers-disallowed.egg | 4 + tests/fail-typecheck/repro-duplicated-var.egg | 3 + tests/fail-typecheck/unbound.egg | 6 + .../unstable-fn-wrong-args-type.egg | 8 + .../fail-typecheck/unstable-fn-wrong-args.egg | 8 + .../unstable-fn-wrong-return-type.egg | 8 + .../unstable-fn-wrong-return.egg | 11 + tests/fail_wrong_assertion.egg | 24 + tests/fibonacci-demand.egg | 19 + tests/fibonacci.egg | 11 + tests/files.rs | 131 + tests/fusion.egg | 152 + tests/herbie-tutorial.egg | 137 + tests/herbie.egg | 570 ++ tests/i64.egg | 1 + tests/include.egg | 2 + tests/integer_math.egg | 106 + tests/integration_test.rs | 441 + tests/intersection.egg | 41 + tests/interval.egg | 31 + tests/knapsack.egg | 46 + tests/lambda.egg | 242 + tests/levenshtein-distance.egg | 71 + tests/list.egg | 73 + tests/map.egg | 7 + tests/math-microbenchmark.egg | 73 + tests/math.egg | 144 + tests/matrix.egg | 98 + tests/merge-during-rebuild.egg | 18 + tests/merge-saturates.egg | 24 + tests/multiset.egg | 58 + tests/name-resolution.egg | 25 + tests/path-union.egg | 21 + tests/path.egg | 19 + tests/pathproof.egg | 30 + tests/points-to.egg | 63 + tests/primitives.egg | 5 + tests/prims.egg | 124 + tests/push-pop.egg | 11 + tests/python_array_optimize.egg | 1569 ++++ tests/rational.egg | 14 + tests/repro-define.egg | 9 + tests/repro-desugar-143.egg | 40 + tests/repro-empty-query.egg | 9 + tests/repro-equal-constant.egg | 9 + tests/repro-equal-constant2.egg | 9 + tests/repro-noteqbug.egg | 11 + tests/repro-primitive-query.egg | 12 + tests/repro-querybug.egg | 17 + tests/repro-querybug2.egg | 15 + tests/repro-querybug3.egg | 31 + tests/repro-querybug4.egg | 9 + tests/repro-should-saturate.egg | 10 + tests/repro-silly-panic.egg | 12 + tests/repro-typechecking-schedule.egg | 6 + tests/repro-unsound-htutorial.egg | 16 + tests/repro-unsound.egg | 63 + tests/repro-vec-unequal.egg | 17 + tests/resolution.egg | 101 + tests/rw-analysis.egg | 284 + tests/schedule-demo.egg | 28 + tests/semi_naive_set_function.egg | 104 + tests/set.egg | 40 + tests/stratified.egg | 28 + tests/stresstest_large_expr.egg | 440 + tests/string.egg | 8 + tests/string_quotes.csv | 1 + tests/string_quotes.egg | 3 + tests/subsume.egg | 30 + tests/terms.rs | 33 + tests/test-combined-steps.egg | 53 + tests/test-combined.egg | 33 + tests/towers-of-hanoi.egg | 39 + tests/tricky-type-checking.egg | 138 + tests/type-constraints-tests.egg | 10 + tests/typecheck.egg | 102 + tests/typeinfer.egg | 337 + tests/unification-points-to.egg | 243 + tests/unify.egg | 26 + tests/unstable-fn.egg | 70 + tests/until.egg | 34 + tests/vec.egg | 25 + 111 files changed, 18777 insertions(+), 280 deletions(-) create mode 100644 src/lib.rs create mode 100644 tests/antiunify.egg create mode 100644 tests/array.egg create mode 100644 tests/bdd.egg create mode 100644 tests/before-proofs.egg create mode 100644 tests/bignum.egg create mode 100644 tests/birewrite.egg create mode 100644 tests/bitwise.egg create mode 100644 tests/bool.egg create mode 100644 tests/calc.egg create mode 100644 tests/combinators.egg create mode 100644 tests/combined-nested.egg create mode 100644 tests/container-rebuild.egg create mode 100644 tests/cyk.egg create mode 100644 tests/cykjson.egg create mode 100644 tests/cykjson_End.csv create mode 100644 tests/cykjson_Prod.csv create mode 100644 tests/cykjson_medium_token.csv create mode 100644 tests/cykjson_small_token.csv create mode 100644 tests/datatypes.egg create mode 100644 tests/delete.egg create mode 100644 tests/eggcc-extraction.egg create mode 100644 tests/eqsat-basic-multiset.egg create mode 100644 tests/eqsat-basic.egg create mode 100644 tests/eqsolve.egg create mode 100644 tests/f64.egg create mode 100644 tests/fail-typecheck/repro-containers-disallowed.egg create mode 100644 tests/fail-typecheck/repro-duplicated-var.egg create mode 100644 tests/fail-typecheck/unbound.egg create mode 100644 tests/fail-typecheck/unstable-fn-wrong-args-type.egg create mode 100644 tests/fail-typecheck/unstable-fn-wrong-args.egg create mode 100644 tests/fail-typecheck/unstable-fn-wrong-return-type.egg create mode 100644 tests/fail-typecheck/unstable-fn-wrong-return.egg create mode 100644 tests/fail_wrong_assertion.egg create mode 100644 tests/fibonacci-demand.egg create mode 100644 tests/fibonacci.egg create mode 100644 tests/files.rs create mode 100644 tests/fusion.egg create mode 100644 tests/herbie-tutorial.egg create mode 100644 tests/herbie.egg create mode 100644 tests/i64.egg create mode 100644 tests/include.egg create mode 100644 tests/integer_math.egg create mode 100644 tests/integration_test.rs create mode 100644 tests/intersection.egg create mode 100644 tests/interval.egg create mode 100644 tests/knapsack.egg create mode 100644 tests/lambda.egg create mode 100644 tests/levenshtein-distance.egg create mode 100644 tests/list.egg create mode 100644 tests/map.egg create mode 100644 tests/math-microbenchmark.egg create mode 100644 tests/math.egg create mode 100644 tests/matrix.egg create mode 100644 tests/merge-during-rebuild.egg create mode 100644 tests/merge-saturates.egg create mode 100644 tests/multiset.egg create mode 100644 tests/name-resolution.egg create mode 100644 tests/path-union.egg create mode 100644 tests/path.egg create mode 100644 tests/pathproof.egg create mode 100644 tests/points-to.egg create mode 100644 tests/primitives.egg create mode 100644 tests/prims.egg create mode 100644 tests/push-pop.egg create mode 100644 tests/python_array_optimize.egg create mode 100644 tests/rational.egg create mode 100644 tests/repro-define.egg create mode 100644 tests/repro-desugar-143.egg create mode 100644 tests/repro-empty-query.egg create mode 100644 tests/repro-equal-constant.egg create mode 100644 tests/repro-equal-constant2.egg create mode 100644 tests/repro-noteqbug.egg create mode 100644 tests/repro-primitive-query.egg create mode 100644 tests/repro-querybug.egg create mode 100644 tests/repro-querybug2.egg create mode 100644 tests/repro-querybug3.egg create mode 100644 tests/repro-querybug4.egg create mode 100644 tests/repro-should-saturate.egg create mode 100644 tests/repro-silly-panic.egg create mode 100644 tests/repro-typechecking-schedule.egg create mode 100644 tests/repro-unsound-htutorial.egg create mode 100644 tests/repro-unsound.egg create mode 100644 tests/repro-vec-unequal.egg create mode 100644 tests/resolution.egg create mode 100644 tests/rw-analysis.egg create mode 100644 tests/schedule-demo.egg create mode 100644 tests/semi_naive_set_function.egg create mode 100644 tests/set.egg create mode 100644 tests/stratified.egg create mode 100644 tests/stresstest_large_expr.egg create mode 100644 tests/string.egg create mode 100644 tests/string_quotes.csv create mode 100644 tests/string_quotes.egg create mode 100644 tests/subsume.egg create mode 100644 tests/terms.rs create mode 100644 tests/test-combined-steps.egg create mode 100644 tests/test-combined.egg create mode 100644 tests/towers-of-hanoi.egg create mode 100644 tests/tricky-type-checking.egg create mode 100644 tests/type-constraints-tests.egg create mode 100644 tests/typecheck.egg create mode 100644 tests/typeinfer.egg create mode 100644 tests/unification-points-to.egg create mode 100644 tests/unify.egg create mode 100644 tests/unstable-fn.egg create mode 100644 tests/until.egg create mode 100644 tests/vec.egg diff --git a/Cargo.lock b/Cargo.lock index 8e3c729..1519d1e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,29 +2,6 @@ # It is not intended for manual editing. version = 3 -[[package]] -name = "ahash" -version = "0.7.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" -dependencies = [ - "getrandom", - "once_cell", - "version_check", -] - -[[package]] -name = "ahash" -version = "0.8.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011" -dependencies = [ - "cfg-if", - "once_cell", - "version_check", - "zerocopy", -] - [[package]] name = "aho-corasick" version = "1.1.3" @@ -40,6 +17,12 @@ version = "0.2.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + [[package]] name = "anstream" version = "0.6.18" @@ -89,36 +72,12 @@ dependencies = [ "windows-sys 0.59.0", ] -[[package]] -name = "ascii-canvas" -version = "3.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6" -dependencies = [ - "term", -] - [[package]] name = "autocfg" version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" -[[package]] -name = "bit-set" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1" -dependencies = [ - "bit-vec", -] - -[[package]] -name = "bit-vec" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" - [[package]] name = "bitflags" version = "2.6.0" @@ -143,12 +102,24 @@ dependencies = [ "generic-array", ] +[[package]] +name = "bumpalo" +version = "3.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" + [[package]] name = "byteorder" version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + [[package]] name = "cfg-if" version = "1.0.0" @@ -164,6 +135,33 @@ dependencies = [ "num-traits", ] +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + [[package]] name = "clap" version = "4.5.21" @@ -204,12 +202,44 @@ version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "afb84c814227b90d6895e01398aee0d8033c00e7466aca416fb6a8e0eb19d8a7" +[[package]] +name = "codspeed" +version = "2.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "450a0e9df9df1c154156f4344f99d8f6f6e69d0fc4de96ef6e2e68b2ec3bce97" +dependencies = [ + "colored", + "libc", + "serde_json", +] + +[[package]] +name = "codspeed-criterion-compat" +version = "2.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8eb1a6cb9c20e177fde58cdef97c1c7c9264eb1424fe45c4fccedc2fb078a569" +dependencies = [ + "codspeed", + "colored", + "criterion", +] + [[package]] name = "colorchoice" version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990" +[[package]] +name = "colored" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cbf2150cce219b664a8a70df7a1f933836724b503f8a413af9365b4dcc4d90b8" +dependencies = [ + "lazy_static", + "windows-sys 0.48.0", +] + [[package]] name = "cpufeatures" version = "0.2.16" @@ -219,6 +249,67 @@ dependencies = [ "libc", ] +[[package]] +name = "criterion" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f" +dependencies = [ + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "is-terminal", + "itertools", + "num-traits", + "once_cell", + "oorandom", + "plotters", + "rayon", + "regex", + "serde", + "serde_derive", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1" +dependencies = [ + "cast", + "itertools", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80" + [[package]] name = "crunchy" version = "0.2.2" @@ -245,27 +336,6 @@ dependencies = [ "crypto-common", ] -[[package]] -name = "dirs-next" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1" -dependencies = [ - "cfg-if", - "dirs-sys-next", -] - -[[package]] -name = "dirs-sys-next" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" -dependencies = [ - "libc", - "redox_users", - "winapi", -] - [[package]] name = "dot-generator" version = "0.2.0" @@ -284,27 +354,22 @@ checksum = "675e35c02a51bb4d4618cb4885b3839ce6d1787c97b664474d9208d074742e20" [[package]] name = "egglog" version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e61ae52399232f9baef42e7c9b7c68ae8569fc8812c766859d8cdead28dd8b33" +source = "git+https://github.com/egraphs-good/egglog.git#86cb822cdff4481b9950126a70e21e70320814b0" dependencies = [ "chrono", "clap", "egraph-serialize", "env_logger", "generic_symbolic_expressions", - "hashbrown 0.14.5", + "hashbrown", + "im", "im-rc", "indexmap", "instant", - "lalrpop", - "lalrpop-util", "lazy_static", "log", - "num-integer", - "num-rational", - "num-traits", + "num", "ordered-float", - "regex", "rustc-hash", "serde_json", "smallvec", @@ -316,7 +381,10 @@ dependencies = [ name = "egglog-experimental" version = "0.1.0" dependencies = [ + "codspeed-criterion-compat", "egglog", + "glob", + "libtest-mimic", ] [[package]] @@ -339,15 +407,6 @@ version = "1.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" -[[package]] -name = "ena" -version = "0.14.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d248bdd43ce613d87415282f69b9bb99d947d290b10962dd6c56233312c2ad5" -dependencies = [ - "log", -] - [[package]] name = "env_logger" version = "0.10.2" @@ -384,10 +443,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "486f806e73c5707928240ddc295403b1b93c96a02038563881c4a2fd84b81ac4" [[package]] -name = "fixedbitset" -version = "0.4.2" +name = "foldhash" +version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" +checksum = "f81ec6369c545a7d40e4589b5597581fa1c441fe1cce96dd1de43159910a36a2" [[package]] name = "generic-array" @@ -416,6 +475,12 @@ dependencies = [ "wasi", ] +[[package]] +name = "glob" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" + [[package]] name = "graphviz-rust" version = "0.6.6" @@ -433,36 +498,38 @@ dependencies = [ ] [[package]] -name = "hashbrown" -version = "0.12.3" +name = "half" +version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" +checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888" dependencies = [ - "ahash 0.7.8", + "cfg-if", + "crunchy", ] [[package]] name = "hashbrown" -version = "0.14.5" +version = "0.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" +checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" dependencies = [ - "ahash 0.8.11", "allocator-api2", + "equivalent", + "foldhash", ] -[[package]] -name = "hashbrown" -version = "0.15.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" - [[package]] name = "heck" version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" +[[package]] +name = "hermit-abi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024" + [[package]] name = "hermit-abi" version = "0.4.0" @@ -475,6 +542,20 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" +[[package]] +name = "im" +version = "15.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0acd33ff0285af998aaf9b57342af478078f53492322fafc47450e09397e0e9" +dependencies = [ + "bitmaps", + "rand_core", + "rand_xoshiro", + "sized-chunks", + "typenum", + "version_check", +] + [[package]] name = "im-rc" version = "15.1.0" @@ -496,7 +577,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f" dependencies = [ "equivalent", - "hashbrown 0.15.2", + "hashbrown", "serde", ] @@ -537,7 +618,7 @@ version = "0.4.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b" dependencies = [ - "hermit-abi", + "hermit-abi 0.4.0", "libc", "windows-sys 0.52.0", ] @@ -550,9 +631,9 @@ checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" [[package]] name = "itertools" -version = "0.11.0" +version = "0.10.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57" +checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" dependencies = [ "either", ] @@ -564,34 +645,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674" [[package]] -name = "lalrpop" -version = "0.20.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55cb077ad656299f160924eb2912aa147d7339ea7d69e1b5517326fdcec3c1ca" -dependencies = [ - "ascii-canvas", - "bit-set", - "ena", - "itertools", - "lalrpop-util", - "petgraph", - "pico-args", - "regex", - "regex-syntax", - "string_cache", - "term", - "tiny-keccak", - "unicode-xid", - "walkdir", -] - -[[package]] -name = "lalrpop-util" -version = "0.20.2" +name = "js-sys" +version = "0.3.74" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "507460a910eb7b32ee961886ff48539633b788a36b65692b95f225b844c82553" +checksum = "a865e038f7f6ed956f788f0d7d60c541fff74c7bd74272c5d4cf15c63743e705" dependencies = [ - "regex-automata", + "once_cell", + "wasm-bindgen", ] [[package]] @@ -607,13 +667,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09d6582e104315a817dff97f75133544b2e094ee22447d2acf4a74e189ba06fc" [[package]] -name = "libredox" -version = "0.1.3" +name = "libtest-mimic" +version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" +checksum = "6d8de370f98a6cb8a4606618e53e802f93b094ddec0f96988eaec2c27e6e9ce7" dependencies = [ - "bitflags", - "libc", + "clap", + "termcolor", + "threadpool", ] [[package]] @@ -622,16 +683,6 @@ version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" -[[package]] -name = "lock_api" -version = "0.4.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17" -dependencies = [ - "autocfg", - "scopeguard", -] - [[package]] name = "log" version = "0.4.22" @@ -645,10 +696,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] -name = "new_debug_unreachable" -version = "1.0.6" +name = "num" +version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086" +checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23" +dependencies = [ + "num-bigint", + "num-complex", + "num-integer", + "num-iter", + "num-rational", + "num-traits", +] [[package]] name = "num-bigint" @@ -660,6 +719,15 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num-complex" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" +dependencies = [ + "num-traits", +] + [[package]] name = "num-integer" version = "0.1.46" @@ -669,6 +737,17 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num-iter" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + [[package]] name = "num-rational" version = "0.4.2" @@ -689,12 +768,28 @@ dependencies = [ "autocfg", ] +[[package]] +name = "num_cpus" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" +dependencies = [ + "hermit-abi 0.3.9", + "libc", +] + [[package]] name = "once_cell" version = "1.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775" +[[package]] +name = "oorandom" +version = "11.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b410bbe7e14ab526a0e86877eb47c6996a2bd7746f027ba551028c925390e4e9" + [[package]] name = "ordered-float" version = "3.9.2" @@ -706,29 +801,6 @@ dependencies = [ "serde", ] -[[package]] -name = "parking_lot" -version = "0.12.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27" -dependencies = [ - "lock_api", - "parking_lot_core", -] - -[[package]] -name = "parking_lot_core" -version = "0.9.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" -dependencies = [ - "cfg-if", - "libc", - "redox_syscall", - "smallvec", - "windows-targets", -] - [[package]] name = "pest" version = "2.7.14" @@ -775,29 +847,32 @@ dependencies = [ ] [[package]] -name = "petgraph" -version = "0.6.5" +name = "plotters" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db" +checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747" dependencies = [ - "fixedbitset", - "indexmap", + "num-traits", + "plotters-backend", + "plotters-svg", + "wasm-bindgen", + "web-sys", ] [[package]] -name = "phf_shared" -version = "0.10.0" +name = "plotters-backend" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096" -dependencies = [ - "siphasher", -] +checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a" [[package]] -name = "pico-args" -version = "0.5.0" +name = "plotters-svg" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315" +checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670" +dependencies = [ + "plotters-backend", +] [[package]] name = "ppv-lite86" @@ -808,12 +883,6 @@ dependencies = [ "zerocopy", ] -[[package]] -name = "precomputed-hash" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" - [[package]] name = "proc-macro2" version = "1.0.92" @@ -874,23 +943,23 @@ dependencies = [ ] [[package]] -name = "redox_syscall" -version = "0.5.7" +name = "rayon" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f" +checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa" dependencies = [ - "bitflags", + "either", + "rayon-core", ] [[package]] -name = "redox_users" -version = "0.4.6" +name = "rayon-core" +version = "1.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43" +checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2" dependencies = [ - "getrandom", - "libredox", - "thiserror", + "crossbeam-deque", + "crossbeam-utils", ] [[package]] @@ -941,12 +1010,6 @@ dependencies = [ "windows-sys 0.52.0", ] -[[package]] -name = "rustversion" -version = "1.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e819f2bc632f285be6d7cd36e25940d45b2391dd6d9b939e79de557f7014248" - [[package]] name = "ryu" version = "1.0.18" @@ -962,12 +1025,6 @@ dependencies = [ "winapi-util", ] -[[package]] -name = "scopeguard" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" - [[package]] name = "serde" version = "1.0.215" @@ -1012,12 +1069,6 @@ dependencies = [ "digest", ] -[[package]] -name = "siphasher" -version = "0.3.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d" - [[package]] name = "sized-chunks" version = "0.6.5" @@ -1034,19 +1085,6 @@ version = "1.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" -[[package]] -name = "string_cache" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f91138e76242f575eb1d3b38b4f1362f10d3a43f47d182a5b359af488a02293b" -dependencies = [ - "new_debug_unreachable", - "once_cell", - "parking_lot", - "phf_shared", - "precomputed-hash", -] - [[package]] name = "strsim" version = "0.11.1" @@ -1055,12 +1093,13 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" [[package]] name = "symbol_table" -version = "0.3.0" +version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "828f672b631c220bf6ea8a1d3b82c7d0fc998e5ba8373383d8604bc1e2a6245a" +checksum = "f19bffd69fb182e684d14e3c71d04c0ef33d1641ac0b9e81c712c734e83703bc" dependencies = [ - "ahash 0.7.8", - "hashbrown 0.12.3", + "crossbeam-utils", + "foldhash", + "hashbrown", ] [[package]] @@ -1098,17 +1137,6 @@ dependencies = [ "windows-sys 0.59.0", ] -[[package]] -name = "term" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f" -dependencies = [ - "dirs-next", - "rustversion", - "winapi", -] - [[package]] name = "termcolor" version = "1.4.1" @@ -1139,12 +1167,22 @@ dependencies = [ ] [[package]] -name = "tiny-keccak" -version = "2.0.2" +name = "threadpool" +version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" +checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa" dependencies = [ - "crunchy", + "num_cpus", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", ] [[package]] @@ -1165,12 +1203,6 @@ version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83" -[[package]] -name = "unicode-xid" -version = "0.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" - [[package]] name = "utf8parse" version = "0.2.2" @@ -1200,20 +1232,69 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" [[package]] -name = "winapi" -version = "0.3.9" +name = "wasm-bindgen" +version = "0.2.97" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +checksum = "d15e63b4482863c109d70a7b8706c1e364eb6ea449b201a76c5b89cedcec2d5c" dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", + "cfg-if", + "once_cell", + "wasm-bindgen-macro", ] [[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" +name = "wasm-bindgen-backend" +version = "0.2.97" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d36ef12e3aaca16ddd3f67922bc63e48e953f126de60bd33ccc0101ef9998cd" +dependencies = [ + "bumpalo", + "log", + "once_cell", + "proc-macro2", + "quote", + "syn 2.0.90", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.97" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "705440e08b42d3e4b36de7d66c944be628d579796b8090bfa3471478a2260051" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.97" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98c9ae5a76e46f4deecd0f0255cc223cfa18dc9b261213b8aa0c7b36f61b3f1d" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.90", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.97" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ee99da9c5ba11bd675621338ef6fa52296b76b83305e9b6e5c77d4c286d6d49" + +[[package]] +name = "web-sys" +version = "0.3.74" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" +checksum = "a98bc3c33f0fe7e59ad7cd041b89034fa82a7c2d4365ca538dda6cdaf513863c" +dependencies = [ + "js-sys", + "wasm-bindgen", +] [[package]] name = "winapi-util" @@ -1225,10 +1306,13 @@ dependencies = [ ] [[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" +name = "windows-sys" +version = "0.48.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" +dependencies = [ + "windows-targets 0.48.5", +] [[package]] name = "windows-sys" @@ -1236,7 +1320,7 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" dependencies = [ - "windows-targets", + "windows-targets 0.52.6", ] [[package]] @@ -1245,7 +1329,22 @@ version = "0.59.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" dependencies = [ - "windows-targets", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-targets" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" +dependencies = [ + "windows_aarch64_gnullvm 0.48.5", + "windows_aarch64_msvc 0.48.5", + "windows_i686_gnu 0.48.5", + "windows_i686_msvc 0.48.5", + "windows_x86_64_gnu 0.48.5", + "windows_x86_64_gnullvm 0.48.5", + "windows_x86_64_msvc 0.48.5", ] [[package]] @@ -1254,28 +1353,46 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" dependencies = [ - "windows_aarch64_gnullvm", - "windows_aarch64_msvc", - "windows_i686_gnu", + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", "windows_i686_gnullvm", - "windows_i686_msvc", - "windows_x86_64_gnu", - "windows_x86_64_gnullvm", - "windows_x86_64_msvc", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", ] +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" + [[package]] name = "windows_aarch64_gnullvm" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" + [[package]] name = "windows_aarch64_msvc" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" +[[package]] +name = "windows_i686_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" + [[package]] name = "windows_i686_gnu" version = "0.52.6" @@ -1288,24 +1405,48 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" +[[package]] +name = "windows_i686_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" + [[package]] name = "windows_i686_msvc" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" + [[package]] name = "windows_x86_64_gnu" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" + [[package]] name = "windows_x86_64_gnullvm" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" + [[package]] name = "windows_x86_64_msvc" version = "0.52.6" diff --git a/Cargo.toml b/Cargo.toml index 962c0c2..336a981 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,5 +3,14 @@ name = "egglog-experimental" version = "0.1.0" edition = "2021" +[[test]] +harness = false +name = "files" + [dependencies] -egglog = "0.3.0" +egglog = { git = "https://github.com/egraphs-good/egglog.git" } + +[dev-dependencies] +codspeed-criterion-compat = "2.7.2" +glob = "0.3.1" +libtest-mimic = "0.6.1" diff --git a/Makefile b/Makefile index af6ab7b..b592ed5 100644 --- a/Makefile +++ b/Makefile @@ -1,3 +1,5 @@ +WWW=${PWD}/target/www/ + all: test nits docs test: diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..f8888fc --- /dev/null +++ b/src/lib.rs @@ -0,0 +1 @@ +pub use egglog::*; diff --git a/tests/antiunify.egg b/tests/antiunify.egg new file mode 100644 index 0000000..b9e5554 --- /dev/null +++ b/tests/antiunify.egg @@ -0,0 +1,26 @@ +(datatype Expr + (Num i64) + (Var String) + (Add Expr Expr)) + +(rewrite (Add x y) (Add y x)) +(rewrite (Add (Num x) (Num y)) (Num (+ x y))) + +;; antiunificaiton returns an expression that could unify with either +;; of the input expressions +;; (AU x y) can be considered a placeholder variable +(function AU (Expr Expr) Expr) + +(rewrite (AU x x) x) +(rewrite + (AU (Add a b) (Add c d)) + (Add (AU a c) (AU b d))) + +(let e1 (Add (Var "x") (Add (Num 1) (Num 2)))) +(let e2 (Add (Num 3) (Var "y"))) + +(let au12 (AU e1 e2)) + +(run 4) +(check (= au12 (Add (Num 3) (AU (Var "x") (Var "y"))))) +(query-extract au12) diff --git a/tests/array.egg b/tests/array.egg new file mode 100644 index 0000000..f985aec --- /dev/null +++ b/tests/array.egg @@ -0,0 +1,77 @@ +; Smtlib theory of arrays +; https://smtlib.cs.uiowa.edu/theories-ArraysEx.shtml +; http://smtlib.cs.uiowa.edu/version1/theories/Arrays.smt + +(datatype Math + (Num i64) + (Var String) +) + + +(datatype Array + (Const i64) + (AVar String) +) + +(function add (Math Math) Math) +(function select (Array Math) Math) +(function store (Array Math Math) Array) + +(relation neq (Math Math)) + +(rule ((neq x y)) + ((neq y x))) + +(rule ((neq x x)) + ((panic "query (neq x x) found something equal to itself"))) + + +; injectivity rules take not equal to not equal. +(rule ((neq x y) (= (add x z) e)) + ((neq (add x z) (add y z)))) +(rule ((= (add x (Num i)) e) (!= i 0)) + ((neq e x))) + + +(rule ((= (Num a) n1) (= (Num b) n2) (!= a b)) + ((neq n1 n2))) + +; select gets from store +(rewrite (select (store mem i e) i) e) +; select passes through wrong index +(rule ((= (select (store mem i1 e) i2) e1) (neq i1 i2)) + ((union (select mem i2) e1))) +; aliasing writes destroy old value +(rewrite (store (store mem i e1) i e2) (store mem i e2)) +; non-aliasing writes commutes +(rule ((= (store (store mem i2 e2) i1 e1) mem1) (neq i1 i2)) + ((union (store (store mem i1 e1) i2 e2) mem1))) + +; typical math rules +(rewrite (add x y) (add y x)) +(rewrite (add (add x y) z) (add x (add y z))) +(rewrite (add (Num x) (Num y)) (Num (+ x y))) +(rewrite (add x (Num 0)) x) + +(push) +(let r1 (Var "r1")) +(let r2 (Var "r2")) +(let r3 (Var "r3")) +(let mem1 (AVar "mem1")) + +(neq r1 r2) +(neq r2 r3) +(neq r1 r3) +(let test1 (select (store mem1 r1 (Num 42)) r1)) +(let test2 (select (store mem1 r1 (Num 42)) (add r1 (Num 17)))) +(let test3 (select (store (store mem1 (add r1 r2) (Num 1)) (add r2 r1) (Num 2)) (add r1 r3))) +(let test4 (add (Num 1) (add (add (Num 1) (add (Num 1) r1)) (Num -3)))) + +(run 5) +(check (= test1 (Num 42))) +(check (neq r1 r2)) +(check (neq r1 (add r1 (Num 17)))) +(check (= test2 (select mem1 (add r1 (Num 17))))) +(check (= test3 (select mem1 (add r1 r3)))) +(check (= test4 r1)) +(pop) diff --git a/tests/bdd.egg b/tests/bdd.egg new file mode 100644 index 0000000..db10e51 --- /dev/null +++ b/tests/bdd.egg @@ -0,0 +1,107 @@ +; Binary Decision Diagrams are if-then-else trees/ compressed tries that hash cons their leaves +; This is easily expressible in the facilities provided. Everything in egglog is automatcally shared +; and Compression is easily expressible as a rule. + +; They are a notion of first class set useful for certain classes of uniformly describable sets. +; https://en.wikipedia.org/wiki/Binary_decision_diagram +; https://www.lri.fr/~filliatr/ftp/publis/hash-consing2.pdf Type-Safe Modular Hash-Consing - Section 3.3 + +(datatype BDD + (ITE i64 BDD BDD) ; variables labelled by number +) +(function TrueConst () BDD) +(let True (TrueConst)) +(function FalseConst () BDD) +(let False (FalseConst)) + +; compress unneeded nodes +(rewrite (ITE n a a) a) + +(function bddand (BDD BDD) BDD) +(rewrite (bddand x y) (bddand y x)) +(rewrite (bddand False n) False) +(rewrite (bddand True x) x) + +; We use an order where low variables are higher in tree +; Could go the other way. +(rewrite (bddand (ITE n a1 a2) (ITE m b1 b2)) + (ITE n (bddand a1 (ITE m b1 b2)) (bddand a2 (ITE m b1 b2))) + :when ((< n m)) +) +(rewrite (bddand (ITE n a1 a2) (ITE n b1 b2)) + (ITE n (bddand a1 b1) (bddand a2 b2)) +) + +(function bddor (BDD BDD) BDD) +(rewrite (bddor x y) (bddor y x)) +(rewrite (bddor True n) True) +(rewrite (bddor False x) x) +(rewrite (bddor (ITE n a1 a2) (ITE m b1 b2)) + (ITE n (bddor a1 (ITE m b1 b2)) (bddor a2 (ITE m b1 b2))) + :when ((< n m)) +) +(rewrite (bddor (ITE n a1 a2) (ITE n b1 b2)) + (ITE n (bddor a1 b1) (bddor a2 b2)) +) + +(function bddnot (BDD) BDD) +(rewrite (bddnot True) False) +(rewrite (bddnot False) True) +(rewrite (bddnot (ITE n a1 a2)) (ITE n (bddnot a1) (bddnot a2))) + + +(function bddxor (BDD BDD) BDD) +(rewrite (bddxor x y) (bddxor y x)) +(rewrite (bddxor True n) (bddnot n)) +(rewrite (bddxor False x) x) + +(rewrite (bddxor (ITE n a1 a2) (ITE m b1 b2)) + (ITE n (bddxor a1 (ITE m b1 b2)) (bddxor a2 (ITE m b1 b2))) + :when ((< n m)) +) +(rewrite (bddxor (ITE n a1 a2) (ITE n b1 b2)) + (ITE n (bddxor a1 b1) (bddxor a2 b2)) +) + +(push) +;;; Tests + +(let v0 (ITE 0 True False)) +(let v1 (ITE 1 True False)) +(let v2 (ITE 2 True False)) + +(let t0 (bddnot (bddnot v0))) +(let t1 (bddor v0 (bddnot v0))) +(let t2 (bddand v0 (bddnot v0))) +(let t3 (bddand v0 v0)) +(let t4 (bddor v0 v0)) +(let t5 (bddxor (bddnot v0) v0)) +(let t6 (bddand (bddor v1 v2) v2)) + +(let t7a (bddxor (bddnot v0) v1)) +(let t7b (bddxor v0 (bddnot v1))) +(let t7c (bddnot (bddxor v0 v1))) + +(let t8 (bddand v1 v2)) + +(let t9 (bddand (bddnot v1) (bddand (bddnot v0) (bddxor v0 v1)))) +(let t10 (bddor (bddnot v1) (bddor (bddnot v0) (bddxor v0 (bddnot v1))))) + +(run 30) + +(check (= t0 v0)) ; bddnot cancels +(check (= t1 True)) +(check (= t2 False)) +(check (= t3 v0)) +(check (= t4 v0)) +(check (= t5 True)) +(check (= t6 v2)) + +(check (= t7a t7b)) +(check (= t7a t7c)) + +(check (= t8 (ITE 1 (ITE 2 True False) False))) + +(check (= t9 False)) +(check (= t10 True)) +(pop) diff --git a/tests/before-proofs.egg b/tests/before-proofs.egg new file mode 100644 index 0000000..3becdbb --- /dev/null +++ b/tests/before-proofs.egg @@ -0,0 +1,32 @@ +(datatype Math + (Add Math Math) + (Sub Math Math) + (Const Rational) + (Var String)) + +(rewrite (Add a b) (Add (Add a b) (Const (rational 0 1)))) + +(rewrite (Add a b) (Add b a)) + + +(rewrite (Add a (Add b c)) + (Add (Add a b) c)) + +(let two (rational 2 1)) +(let start1 (Add (Var "x") (Const two))) +;; add original proofs + +(run 3) + + +(check (!= (Var "x") (Const two))) +(check (= (Add (Var "x") (Const two)) + (Add (Const two) (Var "x")))) + +(let zero (Const (rational 0 1))) +(let addx2 (Add (Var "x") (Const two))) +(let addx20 (Add addx2 zero)) +(let addzerofront (Add (Add zero (Var "x")) (Const two))) + +(check (= addx2 + addx20)) diff --git a/tests/bignum.egg b/tests/bignum.egg new file mode 100644 index 0000000..94c1732 --- /dev/null +++ b/tests/bignum.egg @@ -0,0 +1,13 @@ + +(let x (bigint -1234)) +(let y (from-string "2")) +(let z (bigrat x y)) +(check (= (to-string (numer z)) "-617")) + +(function bignums (BigInt BigInt) BigRat) +(set (bignums x y) z) +(check + (= (bignums a b) c) + (= (numer c) (>> a 1)) + (= (denom c) (>> b 1)) +) diff --git a/tests/birewrite.egg b/tests/birewrite.egg new file mode 100644 index 0000000..a97bb63 --- /dev/null +++ b/tests/birewrite.egg @@ -0,0 +1,18 @@ +(datatype Math (Add Math Math) (Lit i64)) + +(birewrite (Add (Add x y) z) (Add x (Add y z))) + +(let a (Lit 1)) +(let b (Lit 2)) +(let c (Lit 3)) + +(let d (Lit 4)) +(let e (Lit 5)) +(let f (Lit 6)) + +(let ex1 (Add (Add a b) c)) +(let ex2 (Add d (Add e f))) + +(run 10) +(check (= ex1 (Add a (Add b c)))) +(check (= ex2 (Add (Add d e) f))) diff --git a/tests/bitwise.egg b/tests/bitwise.egg new file mode 100644 index 0000000..e84fc1a --- /dev/null +++ b/tests/bitwise.egg @@ -0,0 +1,37 @@ +(check (= 0 (& 10 0))) +(check (= 8 (& 8 10))) +(check (= 10 (| 8 10))) +(check (= 2 (^ 8 10))) +(check (= 8 (<< 1 3))) +(check (= 1 (>> 8 3))) +(check (= 2 (% 8 3))) +(check (= 2 (/ 8 3))) +(check (= -1 (not-i64 0))) + +; bitsets +;(function bs-union (i64 i64) i64) +;(rewrite (bs-union a b) (| a b)) + +;(function bs-inter (i64 i64) i64) +;(rewrite (bs-inter a b) (& a b)) + +;(function bs-comp (i64) i64) +;(rewrite (bs-comp a) (bvnot a)) + +; singleton set +;(function bs-sing (i64) i64) +;(rewrite (bs-sing a) (1 << a)) + +;(function bs-insert (i64 i64) i64) +;(rewrite (bs-insert s x) (| s (1 << a)) + +;(function bs-diff (i64 i64) i64) +;(rewrite (bs-diff a b) (^ a (bs-inter a b)) + +;(let bs-empty 0) + +;(let bs-subset (i64 i64) bool) +;(rewrite (bs-subset x y) (is-zero (bs-diff x y))) + +;(let bs-is-elem (i64 i64) bool) +;(rewrite (bs-is-elem s x) (not (is-zero (bs-inter s (sing x))))) diff --git a/tests/bool.egg b/tests/bool.egg new file mode 100644 index 0000000..721e2c9 --- /dev/null +++ b/tests/bool.egg @@ -0,0 +1,39 @@ + +(check (= (and true true) true)) +(check (= (and true false) false)) +(check (= (or true false) true)) +(check (!= (or true false) false)) + +(check (= (bool-= 1 1) true)) +(check (= (bool-= -5 -5) true)) +(check (= (bool-= 1 3) false)) +(check (= (bool-= 3 1) false)) + +(check (= (bool-< 1 2) true)) +(check (= (bool-< 2 1) false)) +(check (= (bool-< 1 1) false)) + +(check (= (bool-<= 1 2) true)) +(check (= (bool-<= 2 1) false)) +(check (= (bool-<= 1 1) true)) + +(check (= (bool-> 1 2) false)) +(check (= (bool-> 2 1) true)) +(check (= (bool-> 1 1) false)) + +(check (= (bool->= 1 2) false)) +(check (= (bool->= 2 1) true)) +(check (= (bool->= 1 1) true)) + +; Test bool's tag +(relation R (i64)) +(function F (i64) bool) + +(rule + ((R i)) + ((set (F i) true)) +) + +(R 0) + +(run 3) diff --git a/tests/calc.egg b/tests/calc.egg new file mode 100644 index 0000000..f53cb81 --- /dev/null +++ b/tests/calc.egg @@ -0,0 +1,61 @@ +(datatype G) +(function IConst () G) +(let I (IConst)) +(function AConst () G) +(let A (AConst)) +(function BConst () G) +(let B (BConst)) +(function g* (G G) G) +(function inv (G) G) +(birewrite (g* (g* a b) c) (g* a (g* b c))) ; assoc +(rewrite (g* I a) a) ; idl +(rewrite (g* a I) a) ; idr +(rewrite (g* (inv a) a) I) ; invl +(rewrite (g* a (inv a)) I) ; invr + +; A is cyclic of period 4 +(rewrite (g* A (g* A (g* A A))) I) + +(let A2 (g* A A)) +(let A4 (g* A2 A2)) +(let A8 (g* A4 A4)) + + +(push) +(g* A4 A4) + +(run 10000 :until (= (g* A4 A4) (g* (g* A2 A2) (g* A2 A2)))) + +(check (= (g* A4 A4) (g* (g* A2 A2) (g* A2 A2)))) +(pop) + +(push) +(g* (g* A2 A2) (g* A2 A2)) + +(run 10000 :until (= (g* (g* A2 A2) (g* A2 A2)) +(g* A2 (g* A2 (g* A2 A2))))) +(check (= (g* (g* A2 A2) (g* A2 A2)) +(g* A2 (g* A2 (g* A2 A2))))) +(pop) + + +(function aConst () G) +(function bConst () G) +(let a (aConst)) +(let b (bConst)) +(push) + +(g* (g* b (g* (inv a) a)) (inv b)) + +(run 100000 :until (= (g* (g* b (g* (inv a) a)) (inv b)) (g* b (inv b)))) + +(check (= (g* (g* b (g* (inv a) a)) (inv b)) (g* b (inv b)))) + +(pop) + +(push) +(g* b (inv b)) +(run 100000 :until (= (g* b (inv b)) I)) +(check (= (g* b (inv b)) I)) + +(pop) diff --git a/tests/combinators.egg b/tests/combinators.egg new file mode 100644 index 0000000..8bf57d9 --- /dev/null +++ b/tests/combinators.egg @@ -0,0 +1,102 @@ +; Substitution in lambda-calculus via S/K/I combinators. Extremely slow, as +; abstraction elimination does not pay attention to whether variables are free +; in an expression before introducing 'S'. +; +; Provides an example of how to implement substitution by embedding in a +; 'richer' data-type and then mapping back to syntax. + +(datatype Expr + (Var String :cost 100) + (Abs String Expr) + (If Expr Expr Expr) + (N i64) + (Add Expr Expr) + (App Expr Expr)) +(function TConst () Expr) +(let T (TConst)) +(function FConst () Expr) +(let F (FConst)) + + +; (\x. (if x then 0 else 1) + 2) false +(let test + (App + (Abs "x" (Add (If (Var "x") (N 0) (N 1)) (N 2))) F)) + +(datatype CExpr + (CVar String :cost 10000) ; (variables that haven't been eliminated yet) + (CAbs String CExpr :cost 10000) ; (abstractions that haven't been eliminated yet) + (CN i64) + (CApp CExpr CExpr)) +(function CTConst () CExpr) +(let CT (CTConst)) +(function CFConst () CExpr) +(let CF (CFConst)) +(function CIfConst () CExpr) +(let CIf (CIfConst)) +(function CAddConst () CExpr) +(let CAdd (CAddConst)) +(function SConst () CExpr) +(let S (SConst)) +(function KConst () CExpr) +(let K (KConst)) +(function IConst () CExpr) +(let I (IConst)) + +;;;; Conversion functions +(function Comb (Expr) CExpr :cost 1000000) +(function Uncomb (CExpr) Expr) +(rewrite (Comb (Uncomb cx)) cx) +(rewrite (Uncomb (Comb x)) x) + +; Mechanical mappings back and forth. +; Note: we avoid resugaring S/K/I +(rule ((= x (N n))) ((union (Comb x) (CN n)))) +(rule ((= cx (CN n))) ((union (Uncomb cx) (N n)))) +(rule ((= x T)) ((union (Comb x) CT))) +(rule ((= cx CT)) ((union (Uncomb cx) T))) +(rule ((= x F)) ((union (Comb x) CF))) +(rule ((= cx CF)) ((union (Uncomb cx) F))) + +(rule ((= x (If c t f))) + ((union (Comb x) (CApp (CApp (CApp CIf (Comb c)) (Comb t)) (Comb f))))) +(rule ((= cx (CApp (CApp (CApp CIf cc) ct) cf))) + ((union (Uncomb cx) (If (Uncomb cc) (Uncomb ct) (Uncomb cf))))) + +(rule ((= x (Add l r))) + ((union (Comb x) (CApp (CApp CAdd (Comb l)) (Comb r))))) +(rule ((= cx (CApp (CApp CAdd cl) cr))) + ((union (Uncomb cx) (Add (Uncomb cl) (Uncomb cr))))) +(rule ((= x (App f a))) ((union (Comb x) (CApp (Comb f) (Comb a))))) + +(rule ((= x (Var v))) ((union (Comb x) (CVar v)))) +(rule ((= x (Abs v body))) ((union (Comb x) (CAbs v (Comb body))))) + +;;;; Abstraction Elimination +(rewrite (CAbs v (CVar v)) I) +; Hacks, could be replaced by !free computation. +(rewrite (CAbs v1 (CVar v2)) (CApp K (CVar v2)) + :when ((!= v1 v2))) +(rewrite (CAbs v (CN n)) (CApp K (CN n))) +(rewrite (CAbs v CT) (CApp K CT)) +(rewrite (CAbs v CF) (CApp K CF)) +(rewrite (CAbs v CIf) (CApp K CIf)) +(rewrite (CAbs v CAdd) (CApp K CAdd)) +(rewrite (CAbs v (CApp x y)) (CApp (CApp S (CAbs v x)) (CAbs v y))) +; May be needed for multiple nested variables +(rewrite (CAbs v (CApp K (CVar v))) K) + +;;;; Primitive Evaluation rules (letd on "surface syntax") +(rewrite (If T t f) t) +(rewrite (If F t f) f) +(rewrite (Add (N n) (N m)) (N (+ n m))) + +;;;; Substitution Rules (letd on the combinator representation) +(rewrite (CApp I cx) cx) +(rewrite (CApp (CApp K cx) cy) cx) +; Without demand, this can cause an explosion in DB size. +(rewrite (CApp (CApp (CApp S cx) cy) cz) (CApp (CApp cx cz) (CApp cy cz))) + +(run 11) +(query-extract (Comb test)) +(check (= test (N 3))) \ No newline at end of file diff --git a/tests/combined-nested.egg b/tests/combined-nested.egg new file mode 100644 index 0000000..e0d7af3 --- /dev/null +++ b/tests/combined-nested.egg @@ -0,0 +1,48 @@ +(relation number (i64)) + + +(ruleset myrules1) +(rule () + ((number 1)) + :ruleset myrules1) +(ruleset myrules2) +(rule () + ((number 2)) + :ruleset myrules2) + +(unstable-combined-ruleset rules1and2 + myrules1 myrules2) + +;; allowed to add to myrules2 and the change is reflected +(rule () + ((number 3)) + :ruleset myrules2) + +;; not allowed to add to combined ruleset +(fail + (rule () + ((number 4)) + :ruleset myrules1and2)) + + +(fail + (rule () + ((number 4)) + :ruleset unboundruleset)) + +(ruleset myrules5) +(rule () + ((number 5)) + :ruleset myrules5) + +(unstable-combined-ruleset rules1and2and5 + rules1and2 myrules5) + +(run-schedule + rules1and2and5) + +(check (number 1)) +(check (number 2)) +(check (number 3)) +(check (number 5)) +(fail (check (number 4))) diff --git a/tests/container-rebuild.egg b/tests/container-rebuild.egg new file mode 100644 index 0000000..3394a00 --- /dev/null +++ b/tests/container-rebuild.egg @@ -0,0 +1,80 @@ +(push) +(datatype Math + (Num i64)) + +(sort MathVec (Vec Math)) + +(let v1 (vec-of (Num 1) (Num 2))) +(let v2 (vec-of (Num 2) (Num 2))) + +(union (Num 1) (Num 2)) + +(check (= v1 v2)) + +(function MyVec (MathVec) Math) + +(MyVec v1) + +(check (MyVec v2)) + +(check (= (MyVec v1) (MyVec v2))) + +(let v3 (vec-of (Num 4) (Num 5))) + +(union (Num 4) (Num 6)) +(union (Num 5) (Num 7)) + +;; We don't have any (MyVec v3) yet +(fail (check (= (MyVec v3) (MyVec (vec-of (Num 6) (Num 7)))))) + +(MyVec v3) +(check (= (MyVec v3) (MyVec (vec-of (Num 6) (Num 7))))) + +(pop) + +(push) + +(datatype Math + (Num i64)) + +(sort MathVec (Vec Math)) + + +(let v1 (vec-of (Num 1) (Num 2))) +(let v2 (vec-of (Num 2) (Num 2))) + +(union (Num 1) (Num 2)) + +(function MyVec (MathVec) Math) + +;; make a reference to v1 +(MyVec v1) + +(extract (MyVec v1)) + +;; rebuilding creates (MyVec v2) +(check (= (MyVec v1) (MyVec v2))) +(pop) + +(push) +(datatype Math + (Add i64 i64) + (Expensive :cost 100)) + +(sort MathVec (Vec Math)) + +(let myvec (vec-of (Expensive))) +(let cheapvec (vec-of (Add 1 2))) + +(function VecContainer (MathVec) Math) + +(let myvecontainer (VecContainer cheapvec)) + + +(union myvecontainer (Expensive)) + +;; (vec-push (vec-empty) (VecContainer (vec-push (vec-empty) (Add 1 2)))) +;; should have cost 4 +(extract myvec 0) + +(pop) \ No newline at end of file diff --git a/tests/cyk.egg b/tests/cyk.egg new file mode 100644 index 0000000..9bd0ef9 --- /dev/null +++ b/tests/cyk.egg @@ -0,0 +1,115 @@ +(datatype term (Term String)) +(datatype nonterm (NonTerm String)) +(datatype tree (NT String tree tree) + (T String String)) + +(function getString (i64) String) + +(relation Prod (nonterm nonterm nonterm)) +(relation End (nonterm String)) + + + +(relation P (i64 i64 nonterm)) +(function B (i64 i64 nonterm) tree :cost 1000) + +(rule ((End (NonTerm a) s) + (= s (getString pos))) + ((P 1 pos (NonTerm a)) + (union (B 1 pos (NonTerm a)) (T a s)))) + +(rule ((Prod (NonTerm a) (NonTerm b) (NonTerm c)) ;; a -> bc + (P p1 s (NonTerm b)) + (P p2 (+ s p1) (NonTerm c))) + ((P (+ p1 p2) s (NonTerm a)))) + + +(rule ((Prod (NonTerm a) (NonTerm b) (NonTerm c)) + (= f1 (B p1 s (NonTerm b))) + (= f2 (B p2 (+ s p1) (NonTerm c)))) + ((union (B (+ p1 p2) s (NonTerm a)) + (NT a f1 f2)))) + +(push) + + +(set (getString 1) "she") +(set (getString 2) "eats") +(set (getString 3) "a") +(set (getString 4) "fish") +(set (getString 5) "with") +(set (getString 6) "a") +(set (getString 7) "fork") + + +(Prod (NonTerm "S") (NonTerm "NP") (NonTerm "VP")) +(Prod (NonTerm "VP") (NonTerm "VP") (NonTerm "PP")) +(Prod (NonTerm "VP") (NonTerm "V") (NonTerm "NP")) +(End (NonTerm "VP") "eats") +(Prod (NonTerm "PP") (NonTerm "P") (NonTerm "NP")) +(Prod (NonTerm "NP") (NonTerm "DET") (NonTerm "N")) +(End (NonTerm "NP") "she") +(End (NonTerm "V") "eats") +(End (NonTerm "P") "with") +(End (NonTerm "N") "fish") +(End (NonTerm "N") "fork") +(End (NonTerm "DET") "a") + + +(let test1 (B 7 1 (NonTerm "S"))) + +(run 100) + +(check (P 7 1 (NonTerm "S"))) +(fail (check (P 7 1 (NonTerm "VP")))) +(fail (check (P 7 1 (NonTerm "")))) + +(query-extract test1) + +(pop) + +(push) + +(Prod (NonTerm "S") (NonTerm "A") (NonTerm "B")) +(Prod (NonTerm "S") (NonTerm "B") (NonTerm "C")) +(Prod (NonTerm "A") (NonTerm "B") (NonTerm "A")) +(End (NonTerm "A") "a") +(Prod (NonTerm "B") (NonTerm "C") (NonTerm "C")) +(End (NonTerm "B") "b") +(Prod (NonTerm "C") (NonTerm "A") (NonTerm "B")) +(End (NonTerm "C") "a") + +(push) + +(set (getString 1) "a") +(set (getString 2) "b") +(set (getString 3) "a") +(set (getString 4) "a") +(set (getString 5) "b") + +(run 100) +(check (P 5 1 (NonTerm "S"))) +(fail (check (P 5 1 (NonTerm "B")))) +(let test2 (B 5 1 (NonTerm "S"))) +(query-extract:variants 10 test2) + +(pop) + +(push) + +(set (getString 1) "a") +(set (getString 2) "a") +(set (getString 3) "a") +(set (getString 4) "a") +(set (getString 5) "a") + +(run 100) +(check (P 5 1 (NonTerm "S"))) +(check (P 5 1 (NonTerm "A"))) +(fail (check (P 5 1 (NonTerm "B")))) +(fail (check (P 5 1 (NonTerm "")))) +(fail (check (P 5 1 (NonTerm "unrelated")))) +(let test3 (B 5 1 (NonTerm "S"))) +(query-extract :variants 10 test3) + +(pop) \ No newline at end of file diff --git a/tests/cykjson.egg b/tests/cykjson.egg new file mode 100644 index 0000000..3c595df --- /dev/null +++ b/tests/cykjson.egg @@ -0,0 +1,44 @@ +(datatype tree (NT String tree tree) + (T String String)) + +(function getString (i64) String) + +(relation Prod (String String String)) +(relation End (String String)) + + +(relation P (i64 i64 String)) +(function B (i64 i64 String) tree :cost 100000) + +(rule ((End a s) + (= s (getString pos))) + ((P 1 pos a) + (union (B 1 pos a) (T a s)))) + +(rule ((Prod a b c) ;; a -> bc + (P p1 s b) + (P p2 (+ s p1) c)) + ((P (+ p1 p2) s a))) + + +(rule ((Prod a b c) + (= f1 (B p1 s b)) + (= f2 (B p2 (+ s p1) c))) + ((union (B (+ p1 p2) s a) + (NT a f1 f2)))) + + +(input Prod "./tests/cykjson_Prod.csv") +(input End "./tests/cykjson_End.csv") + +; small size 801 +(input getString "./tests/cykjson_small_token.csv") + +; medium size 7821 but runs for 2 min. +;(input getString "./tests/cykjson_medium_token.csv") + +(let test1 (B 801 1 "VAL")) + +(run 10000) + +(check (P 801 1 "VAL")) \ No newline at end of file diff --git a/tests/cykjson_End.csv b/tests/cykjson_End.csv new file mode 100644 index 0000000..5df5616 --- /dev/null +++ b/tests/cykjson_End.csv @@ -0,0 +1,17 @@ +VAL str +VAL num +VAL true +VAL false +VAL null +ELM str +ELM num +ELM true +ELM false +ELM null +H0 { +H1 } +H3 [ +H4 ] +H9 , +H10 str +H11 : \ No newline at end of file diff --git a/tests/cykjson_Prod.csv b/tests/cykjson_Prod.csv new file mode 100644 index 0000000..ba4adac --- /dev/null +++ b/tests/cykjson_Prod.csv @@ -0,0 +1,17 @@ +VAL H0 H1 +VAL H2 H1 +VAL H3 H4 +VAL H5 H4 +MEM H6 MEM +MEM H7 VAL +PR H7 VAL +ELM H8 ELM +ELM H0 H1 +ELM H2 H1 +ELM H3 H4 +ELM H5 H4 +H2 H0 MEM +H5 H3 ELM +H6 PR H9 +H7 H10 H11 +H8 VAL H9 \ No newline at end of file diff --git a/tests/cykjson_medium_token.csv b/tests/cykjson_medium_token.csv new file mode 100644 index 0000000..6bb3a3e --- /dev/null +++ b/tests/cykjson_medium_token.csv @@ -0,0 +1,7821 @@ +1 { +2 str +3 : +4 [ +5 { +6 str +7 : +8 str +9 , +10 str +11 : +12 { +13 str +14 : +15 str +16 , +17 str +18 : +19 num +20 , +21 str +22 : +23 { +24 str +25 : +26 num +27 , +28 str +29 : +30 num +31 } +32 , +33 str +34 : +35 str +36 , +37 str +38 : +39 num +40 , +41 str +42 : +43 { +44 str +45 : +46 num +47 , +48 str +49 : +50 str +51 , +52 str +53 : +54 str +55 , +56 str +57 : +58 str +59 , +60 str +61 : +62 str +63 , +64 str +65 : +66 str +67 } +68 , +69 str +70 : +71 { +72 str +73 : +74 str +75 , +76 str +77 : +78 str +79 } +80 } +81 } +82 , +83 { +84 str +85 : +86 str +87 , +88 str +89 : +90 { +91 str +92 : +93 str +94 , +95 str +96 : +97 num +98 , +99 str +100 : +101 { +102 str +103 : +104 num +105 , +106 str +107 : +108 num +109 } +110 , +111 str +112 : +113 str +114 , +115 str +116 : +117 num +118 , +119 str +120 : +121 { +122 str +123 : +124 num +125 , +126 str +127 : +128 str +129 , +130 str +131 : +132 str +133 , +134 str +135 : +136 str +137 , +138 str +139 : +140 str +141 , +142 str +143 : +144 str +145 } +146 , +147 str +148 : +149 { +150 str +151 : +152 str +153 , +154 str +155 : +156 str +157 } +158 } +159 } +160 , +161 { +162 str +163 : +164 str +165 , +166 str +167 : +168 { +169 str +170 : +171 str +172 , +173 str +174 : +175 num +176 , +177 str +178 : +179 { +180 str +181 : +182 num +183 , +184 str +185 : +186 num +187 } +188 , +189 str +190 : +191 str +192 , +193 str +194 : +195 num +196 , +197 str +198 : +199 { +200 str +201 : +202 num +203 , +204 str +205 : +206 str +207 , +208 str +209 : +210 str +211 , +212 str +213 : +214 str +215 , +216 str +217 : +218 str +219 , +220 str +221 : +222 str +223 } +224 , +225 str +226 : +227 { +228 str +229 : +230 str +231 , +232 str +233 : +234 str +235 } +236 } +237 } +238 , +239 { +240 str +241 : +242 str +243 , +244 str +245 : +246 { +247 str +248 : +249 str +250 , +251 str +252 : +253 num +254 , +255 str +256 : +257 { +258 str +259 : +260 num +261 , +262 str +263 : +264 num +265 } +266 , +267 str +268 : +269 str +270 , +271 str +272 : +273 num +274 , +275 str +276 : +277 { +278 str +279 : +280 num +281 , +282 str +283 : +284 str +285 , +286 str +287 : +288 str +289 , +290 str +291 : +292 str +293 , +294 str +295 : +296 str +297 , +298 str +299 : +300 str +301 } +302 , +303 str +304 : +305 { +306 str +307 : +308 str +309 , +310 str +311 : +312 str +313 } +314 } +315 } +316 , +317 { +318 str +319 : +320 str +321 , +322 str +323 : +324 { +325 str +326 : +327 str +328 , +329 str +330 : +331 num +332 , +333 str +334 : +335 { +336 str +337 : +338 num +339 , +340 str +341 : +342 num +343 } +344 , +345 str +346 : +347 str +348 , +349 str +350 : +351 num +352 , +353 str +354 : +355 { +356 str +357 : +358 num +359 , +360 str +361 : +362 str +363 , +364 str +365 : +366 str +367 , +368 str +369 : +370 str +371 , +372 str +373 : +374 str +375 , +376 str +377 : +378 str +379 } +380 , +381 str +382 : +383 { +384 str +385 : +386 str +387 , +388 str +389 : +390 str +391 } +392 } +393 } +394 , +395 { +396 str +397 : +398 str +399 , +400 str +401 : +402 { +403 str +404 : +405 str +406 , +407 str +408 : +409 num +410 , +411 str +412 : +413 { +414 str +415 : +416 num +417 , +418 str +419 : +420 num +421 } +422 , +423 str +424 : +425 str +426 , +427 str +428 : +429 num +430 , +431 str +432 : +433 { +434 str +435 : +436 num +437 , +438 str +439 : +440 str +441 , +442 str +443 : +444 str +445 , +446 str +447 : +448 str +449 , +450 str +451 : +452 str +453 , +454 str +455 : +456 str +457 } +458 , +459 str +460 : +461 { +462 str +463 : +464 str +465 , +466 str +467 : +468 str +469 } +470 } +471 } +472 , +473 { +474 str +475 : +476 str +477 , +478 str +479 : +480 { +481 str +482 : +483 str +484 , +485 str +486 : +487 num +488 , +489 str +490 : +491 { +492 str +493 : +494 num +495 , +496 str +497 : +498 num +499 } +500 , +501 str +502 : +503 str +504 , +505 str +506 : +507 num +508 , +509 str +510 : +511 { +512 str +513 : +514 num +515 , +516 str +517 : +518 str +519 , +520 str +521 : +522 str +523 , +524 str +525 : +526 str +527 , +528 str +529 : +530 str +531 , +532 str +533 : +534 str +535 } +536 , +537 str +538 : +539 { +540 str +541 : +542 str +543 , +544 str +545 : +546 str +547 } +548 } +549 } +550 , +551 { +552 str +553 : +554 str +555 , +556 str +557 : +558 { +559 str +560 : +561 str +562 , +563 str +564 : +565 num +566 , +567 str +568 : +569 { +570 str +571 : +572 num +573 , +574 str +575 : +576 num +577 } +578 , +579 str +580 : +581 str +582 , +583 str +584 : +585 num +586 , +587 str +588 : +589 { +590 str +591 : +592 num +593 , +594 str +595 : +596 str +597 , +598 str +599 : +600 str +601 , +602 str +603 : +604 str +605 , +606 str +607 : +608 str +609 , +610 str +611 : +612 str +613 } +614 , +615 str +616 : +617 { +618 str +619 : +620 str +621 , +622 str +623 : +624 str +625 } +626 } +627 } +628 , +629 { +630 str +631 : +632 str +633 , +634 str +635 : +636 { +637 str +638 : +639 str +640 , +641 str +642 : +643 num +644 , +645 str +646 : +647 { +648 str +649 : +650 num +651 , +652 str +653 : +654 num +655 } +656 , +657 str +658 : +659 str +660 , +661 str +662 : +663 num +664 , +665 str +666 : +667 { +668 str +669 : +670 num +671 , +672 str +673 : +674 str +675 , +676 str +677 : +678 str +679 , +680 str +681 : +682 str +683 , +684 str +685 : +686 str +687 , +688 str +689 : +690 str +691 } +692 , +693 str +694 : +695 { +696 str +697 : +698 str +699 , +700 str +701 : +702 str +703 } +704 } +705 } +706 , +707 { +708 str +709 : +710 str +711 , +712 str +713 : +714 { +715 str +716 : +717 str +718 , +719 str +720 : +721 num +722 , +723 str +724 : +725 { +726 str +727 : +728 num +729 , +730 str +731 : +732 num +733 } +734 , +735 str +736 : +737 str +738 , +739 str +740 : +741 num +742 , +743 str +744 : +745 { +746 str +747 : +748 num +749 , +750 str +751 : +752 str +753 , +754 str +755 : +756 str +757 , +758 str +759 : +760 str +761 , +762 str +763 : +764 str +765 , +766 str +767 : +768 str +769 } +770 , +771 str +772 : +773 { +774 str +775 : +776 str +777 , +778 str +779 : +780 str +781 } +782 } +783 } +784 , +785 { +786 str +787 : +788 str +789 , +790 str +791 : +792 { +793 str +794 : +795 str +796 , +797 str +798 : +799 num +800 , +801 str +802 : +803 { +804 str +805 : +806 num +807 , +808 str +809 : +810 num +811 } +812 , +813 str +814 : +815 str +816 , +817 str +818 : +819 num +820 , +821 str +822 : +823 { +824 str +825 : +826 num +827 , +828 str +829 : +830 str +831 , +832 str +833 : +834 str +835 , +836 str +837 : +838 str +839 , +840 str +841 : +842 str +843 , +844 str +845 : +846 str +847 } +848 , +849 str +850 : +851 { +852 str +853 : +854 str +855 , +856 str +857 : +858 str +859 } +860 } +861 } +862 , +863 { +864 str +865 : +866 str +867 , +868 str +869 : +870 { +871 str +872 : +873 str +874 , +875 str +876 : +877 num +878 , +879 str +880 : +881 { +882 str +883 : +884 num +885 , +886 str +887 : +888 num +889 } +890 , +891 str +892 : +893 str +894 , +895 str +896 : +897 num +898 , +899 str +900 : +901 { +902 str +903 : +904 num +905 , +906 str +907 : +908 str +909 , +910 str +911 : +912 str +913 , +914 str +915 : +916 str +917 , +918 str +919 : +920 str +921 , +922 str +923 : +924 str +925 } +926 , +927 str +928 : +929 { +930 str +931 : +932 str +933 , +934 str +935 : +936 str +937 } +938 } +939 } +940 , +941 { +942 str +943 : +944 str +945 , +946 str +947 : +948 { +949 str +950 : +951 str +952 , +953 str +954 : +955 num +956 , +957 str +958 : +959 { +960 str +961 : +962 num +963 , +964 str +965 : +966 num +967 } +968 , +969 str +970 : +971 str +972 , +973 str +974 : +975 num +976 , +977 str +978 : +979 { +980 str +981 : +982 num +983 , +984 str +985 : +986 str +987 , +988 str +989 : +990 str +991 , +992 str +993 : +994 str +995 , +996 str +997 : +998 str +999 , +1000 str +1001 : +1002 str +1003 } +1004 , +1005 str +1006 : +1007 { +1008 str +1009 : +1010 str +1011 , +1012 str +1013 : +1014 str +1015 } +1016 } +1017 } +1018 , +1019 { +1020 str +1021 : +1022 str +1023 , +1024 str +1025 : +1026 { +1027 str +1028 : +1029 str +1030 , +1031 str +1032 : +1033 num +1034 , +1035 str +1036 : +1037 { +1038 str +1039 : +1040 num +1041 , +1042 str +1043 : +1044 num +1045 } +1046 , +1047 str +1048 : +1049 str +1050 , +1051 str +1052 : +1053 num +1054 , +1055 str +1056 : +1057 { +1058 str +1059 : +1060 num +1061 , +1062 str +1063 : +1064 str +1065 , +1066 str +1067 : +1068 str +1069 , +1070 str +1071 : +1072 str +1073 , +1074 str +1075 : +1076 str +1077 , +1078 str +1079 : +1080 str +1081 } +1082 , +1083 str +1084 : +1085 { +1086 str +1087 : +1088 str +1089 , +1090 str +1091 : +1092 str +1093 } +1094 } +1095 } +1096 , +1097 { +1098 str +1099 : +1100 str +1101 , +1102 str +1103 : +1104 { +1105 str +1106 : +1107 str +1108 , +1109 str +1110 : +1111 num +1112 , +1113 str +1114 : +1115 { +1116 str +1117 : +1118 num +1119 , +1120 str +1121 : +1122 num +1123 } +1124 , +1125 str +1126 : +1127 str +1128 , +1129 str +1130 : +1131 num +1132 , +1133 str +1134 : +1135 { +1136 str +1137 : +1138 num +1139 , +1140 str +1141 : +1142 str +1143 , +1144 str +1145 : +1146 str +1147 , +1148 str +1149 : +1150 str +1151 , +1152 str +1153 : +1154 str +1155 , +1156 str +1157 : +1158 str +1159 } +1160 , +1161 str +1162 : +1163 { +1164 str +1165 : +1166 str +1167 , +1168 str +1169 : +1170 str +1171 } +1172 } +1173 } +1174 , +1175 { +1176 str +1177 : +1178 str +1179 , +1180 str +1181 : +1182 { +1183 str +1184 : +1185 str +1186 , +1187 str +1188 : +1189 num +1190 , +1191 str +1192 : +1193 { +1194 str +1195 : +1196 num +1197 , +1198 str +1199 : +1200 num +1201 } +1202 , +1203 str +1204 : +1205 str +1206 , +1207 str +1208 : +1209 num +1210 , +1211 str +1212 : +1213 { +1214 str +1215 : +1216 num +1217 , +1218 str +1219 : +1220 str +1221 , +1222 str +1223 : +1224 str +1225 , +1226 str +1227 : +1228 str +1229 , +1230 str +1231 : +1232 str +1233 , +1234 str +1235 : +1236 str +1237 } +1238 , +1239 str +1240 : +1241 { +1242 str +1243 : +1244 str +1245 , +1246 str +1247 : +1248 str +1249 } +1250 } +1251 } +1252 , +1253 { +1254 str +1255 : +1256 str +1257 , +1258 str +1259 : +1260 { +1261 str +1262 : +1263 str +1264 , +1265 str +1266 : +1267 num +1268 , +1269 str +1270 : +1271 { +1272 str +1273 : +1274 num +1275 , +1276 str +1277 : +1278 num +1279 } +1280 , +1281 str +1282 : +1283 str +1284 , +1285 str +1286 : +1287 num +1288 , +1289 str +1290 : +1291 { +1292 str +1293 : +1294 num +1295 , +1296 str +1297 : +1298 str +1299 , +1300 str +1301 : +1302 str +1303 , +1304 str +1305 : +1306 str +1307 , +1308 str +1309 : +1310 str +1311 , +1312 str +1313 : +1314 str +1315 } +1316 , +1317 str +1318 : +1319 { +1320 str +1321 : +1322 str +1323 , +1324 str +1325 : +1326 str +1327 } +1328 } +1329 } +1330 , +1331 { +1332 str +1333 : +1334 str +1335 , +1336 str +1337 : +1338 { +1339 str +1340 : +1341 str +1342 , +1343 str +1344 : +1345 num +1346 , +1347 str +1348 : +1349 { +1350 str +1351 : +1352 num +1353 , +1354 str +1355 : +1356 num +1357 } +1358 , +1359 str +1360 : +1361 str +1362 , +1363 str +1364 : +1365 num +1366 , +1367 str +1368 : +1369 { +1370 str +1371 : +1372 num +1373 , +1374 str +1375 : +1376 str +1377 , +1378 str +1379 : +1380 str +1381 , +1382 str +1383 : +1384 str +1385 , +1386 str +1387 : +1388 str +1389 , +1390 str +1391 : +1392 str +1393 } +1394 , +1395 str +1396 : +1397 { +1398 str +1399 : +1400 str +1401 , +1402 str +1403 : +1404 str +1405 } +1406 } +1407 } +1408 , +1409 { +1410 str +1411 : +1412 str +1413 , +1414 str +1415 : +1416 { +1417 str +1418 : +1419 str +1420 , +1421 str +1422 : +1423 num +1424 , +1425 str +1426 : +1427 { +1428 str +1429 : +1430 num +1431 , +1432 str +1433 : +1434 num +1435 } +1436 , +1437 str +1438 : +1439 str +1440 , +1441 str +1442 : +1443 num +1444 , +1445 str +1446 : +1447 { +1448 str +1449 : +1450 num +1451 , +1452 str +1453 : +1454 str +1455 , +1456 str +1457 : +1458 str +1459 , +1460 str +1461 : +1462 str +1463 , +1464 str +1465 : +1466 str +1467 , +1468 str +1469 : +1470 str +1471 } +1472 , +1473 str +1474 : +1475 { +1476 str +1477 : +1478 str +1479 , +1480 str +1481 : +1482 str +1483 } +1484 } +1485 } +1486 , +1487 { +1488 str +1489 : +1490 str +1491 , +1492 str +1493 : +1494 { +1495 str +1496 : +1497 str +1498 , +1499 str +1500 : +1501 num +1502 , +1503 str +1504 : +1505 { +1506 str +1507 : +1508 num +1509 , +1510 str +1511 : +1512 num +1513 } +1514 , +1515 str +1516 : +1517 str +1518 , +1519 str +1520 : +1521 num +1522 , +1523 str +1524 : +1525 { +1526 str +1527 : +1528 num +1529 , +1530 str +1531 : +1532 str +1533 , +1534 str +1535 : +1536 str +1537 , +1538 str +1539 : +1540 str +1541 , +1542 str +1543 : +1544 str +1545 , +1546 str +1547 : +1548 str +1549 } +1550 , +1551 str +1552 : +1553 { +1554 str +1555 : +1556 str +1557 , +1558 str +1559 : +1560 str +1561 } +1562 } +1563 } +1564 , +1565 { +1566 str +1567 : +1568 str +1569 , +1570 str +1571 : +1572 { +1573 str +1574 : +1575 str +1576 , +1577 str +1578 : +1579 num +1580 , +1581 str +1582 : +1583 { +1584 str +1585 : +1586 num +1587 , +1588 str +1589 : +1590 num +1591 } +1592 , +1593 str +1594 : +1595 str +1596 , +1597 str +1598 : +1599 num +1600 , +1601 str +1602 : +1603 { +1604 str +1605 : +1606 num +1607 , +1608 str +1609 : +1610 str +1611 , +1612 str +1613 : +1614 str +1615 , +1616 str +1617 : +1618 str +1619 , +1620 str +1621 : +1622 str +1623 , +1624 str +1625 : +1626 str +1627 } +1628 , +1629 str +1630 : +1631 { +1632 str +1633 : +1634 str +1635 , +1636 str +1637 : +1638 str +1639 } +1640 } +1641 } +1642 , +1643 { +1644 str +1645 : +1646 str +1647 , +1648 str +1649 : +1650 { +1651 str +1652 : +1653 str +1654 , +1655 str +1656 : +1657 num +1658 , +1659 str +1660 : +1661 { +1662 str +1663 : +1664 num +1665 , +1666 str +1667 : +1668 num +1669 } +1670 , +1671 str +1672 : +1673 str +1674 , +1675 str +1676 : +1677 num +1678 , +1679 str +1680 : +1681 { +1682 str +1683 : +1684 num +1685 , +1686 str +1687 : +1688 str +1689 , +1690 str +1691 : +1692 str +1693 , +1694 str +1695 : +1696 str +1697 , +1698 str +1699 : +1700 str +1701 , +1702 str +1703 : +1704 str +1705 } +1706 , +1707 str +1708 : +1709 { +1710 str +1711 : +1712 str +1713 , +1714 str +1715 : +1716 str +1717 } +1718 } +1719 } +1720 , +1721 { +1722 str +1723 : +1724 str +1725 , +1726 str +1727 : +1728 { +1729 str +1730 : +1731 str +1732 , +1733 str +1734 : +1735 num +1736 , +1737 str +1738 : +1739 { +1740 str +1741 : +1742 num +1743 , +1744 str +1745 : +1746 num +1747 } +1748 , +1749 str +1750 : +1751 str +1752 , +1753 str +1754 : +1755 num +1756 , +1757 str +1758 : +1759 { +1760 str +1761 : +1762 num +1763 , +1764 str +1765 : +1766 str +1767 , +1768 str +1769 : +1770 str +1771 , +1772 str +1773 : +1774 str +1775 , +1776 str +1777 : +1778 str +1779 , +1780 str +1781 : +1782 str +1783 } +1784 , +1785 str +1786 : +1787 { +1788 str +1789 : +1790 str +1791 , +1792 str +1793 : +1794 str +1795 } +1796 } +1797 } +1798 , +1799 { +1800 str +1801 : +1802 str +1803 , +1804 str +1805 : +1806 { +1807 str +1808 : +1809 str +1810 , +1811 str +1812 : +1813 num +1814 , +1815 str +1816 : +1817 { +1818 str +1819 : +1820 num +1821 , +1822 str +1823 : +1824 num +1825 } +1826 , +1827 str +1828 : +1829 str +1830 , +1831 str +1832 : +1833 num +1834 , +1835 str +1836 : +1837 { +1838 str +1839 : +1840 num +1841 , +1842 str +1843 : +1844 str +1845 , +1846 str +1847 : +1848 str +1849 , +1850 str +1851 : +1852 str +1853 , +1854 str +1855 : +1856 str +1857 , +1858 str +1859 : +1860 str +1861 } +1862 , +1863 str +1864 : +1865 { +1866 str +1867 : +1868 str +1869 , +1870 str +1871 : +1872 str +1873 } +1874 } +1875 } +1876 , +1877 { +1878 str +1879 : +1880 str +1881 , +1882 str +1883 : +1884 { +1885 str +1886 : +1887 str +1888 , +1889 str +1890 : +1891 num +1892 , +1893 str +1894 : +1895 { +1896 str +1897 : +1898 num +1899 , +1900 str +1901 : +1902 num +1903 } +1904 , +1905 str +1906 : +1907 str +1908 , +1909 str +1910 : +1911 num +1912 , +1913 str +1914 : +1915 { +1916 str +1917 : +1918 num +1919 , +1920 str +1921 : +1922 str +1923 , +1924 str +1925 : +1926 str +1927 , +1928 str +1929 : +1930 str +1931 , +1932 str +1933 : +1934 str +1935 , +1936 str +1937 : +1938 str +1939 } +1940 , +1941 str +1942 : +1943 { +1944 str +1945 : +1946 str +1947 , +1948 str +1949 : +1950 str +1951 } +1952 } +1953 } +1954 , +1955 { +1956 str +1957 : +1958 str +1959 , +1960 str +1961 : +1962 { +1963 str +1964 : +1965 str +1966 , +1967 str +1968 : +1969 num +1970 , +1971 str +1972 : +1973 { +1974 str +1975 : +1976 num +1977 , +1978 str +1979 : +1980 num +1981 } +1982 , +1983 str +1984 : +1985 str +1986 , +1987 str +1988 : +1989 num +1990 , +1991 str +1992 : +1993 { +1994 str +1995 : +1996 num +1997 , +1998 str +1999 : +2000 str +2001 , +2002 str +2003 : +2004 str +2005 , +2006 str +2007 : +2008 str +2009 , +2010 str +2011 : +2012 str +2013 , +2014 str +2015 : +2016 str +2017 } +2018 , +2019 str +2020 : +2021 { +2022 str +2023 : +2024 str +2025 , +2026 str +2027 : +2028 str +2029 } +2030 } +2031 } +2032 , +2033 { +2034 str +2035 : +2036 str +2037 , +2038 str +2039 : +2040 { +2041 str +2042 : +2043 str +2044 , +2045 str +2046 : +2047 num +2048 , +2049 str +2050 : +2051 { +2052 str +2053 : +2054 num +2055 , +2056 str +2057 : +2058 num +2059 } +2060 , +2061 str +2062 : +2063 str +2064 , +2065 str +2066 : +2067 num +2068 , +2069 str +2070 : +2071 { +2072 str +2073 : +2074 num +2075 , +2076 str +2077 : +2078 str +2079 , +2080 str +2081 : +2082 str +2083 , +2084 str +2085 : +2086 str +2087 , +2088 str +2089 : +2090 str +2091 , +2092 str +2093 : +2094 str +2095 } +2096 , +2097 str +2098 : +2099 { +2100 str +2101 : +2102 str +2103 , +2104 str +2105 : +2106 str +2107 } +2108 } +2109 } +2110 , +2111 { +2112 str +2113 : +2114 str +2115 , +2116 str +2117 : +2118 { +2119 str +2120 : +2121 str +2122 , +2123 str +2124 : +2125 num +2126 , +2127 str +2128 : +2129 { +2130 str +2131 : +2132 num +2133 , +2134 str +2135 : +2136 num +2137 } +2138 , +2139 str +2140 : +2141 str +2142 , +2143 str +2144 : +2145 num +2146 , +2147 str +2148 : +2149 { +2150 str +2151 : +2152 num +2153 , +2154 str +2155 : +2156 str +2157 , +2158 str +2159 : +2160 str +2161 , +2162 str +2163 : +2164 str +2165 , +2166 str +2167 : +2168 str +2169 , +2170 str +2171 : +2172 str +2173 } +2174 , +2175 str +2176 : +2177 { +2178 str +2179 : +2180 str +2181 , +2182 str +2183 : +2184 str +2185 } +2186 } +2187 } +2188 , +2189 { +2190 str +2191 : +2192 str +2193 , +2194 str +2195 : +2196 { +2197 str +2198 : +2199 str +2200 , +2201 str +2202 : +2203 num +2204 , +2205 str +2206 : +2207 { +2208 str +2209 : +2210 num +2211 , +2212 str +2213 : +2214 num +2215 } +2216 , +2217 str +2218 : +2219 str +2220 , +2221 str +2222 : +2223 num +2224 , +2225 str +2226 : +2227 { +2228 str +2229 : +2230 num +2231 , +2232 str +2233 : +2234 str +2235 , +2236 str +2237 : +2238 str +2239 , +2240 str +2241 : +2242 str +2243 , +2244 str +2245 : +2246 str +2247 , +2248 str +2249 : +2250 str +2251 } +2252 , +2253 str +2254 : +2255 { +2256 str +2257 : +2258 str +2259 , +2260 str +2261 : +2262 str +2263 } +2264 } +2265 } +2266 , +2267 { +2268 str +2269 : +2270 str +2271 , +2272 str +2273 : +2274 { +2275 str +2276 : +2277 str +2278 , +2279 str +2280 : +2281 num +2282 , +2283 str +2284 : +2285 { +2286 str +2287 : +2288 num +2289 , +2290 str +2291 : +2292 num +2293 } +2294 , +2295 str +2296 : +2297 str +2298 , +2299 str +2300 : +2301 num +2302 , +2303 str +2304 : +2305 { +2306 str +2307 : +2308 num +2309 , +2310 str +2311 : +2312 str +2313 , +2314 str +2315 : +2316 str +2317 , +2318 str +2319 : +2320 str +2321 , +2322 str +2323 : +2324 str +2325 , +2326 str +2327 : +2328 str +2329 } +2330 , +2331 str +2332 : +2333 { +2334 str +2335 : +2336 str +2337 , +2338 str +2339 : +2340 str +2341 } +2342 } +2343 } +2344 , +2345 { +2346 str +2347 : +2348 str +2349 , +2350 str +2351 : +2352 { +2353 str +2354 : +2355 str +2356 , +2357 str +2358 : +2359 num +2360 , +2361 str +2362 : +2363 { +2364 str +2365 : +2366 num +2367 , +2368 str +2369 : +2370 num +2371 } +2372 , +2373 str +2374 : +2375 str +2376 , +2377 str +2378 : +2379 num +2380 , +2381 str +2382 : +2383 { +2384 str +2385 : +2386 num +2387 , +2388 str +2389 : +2390 str +2391 , +2392 str +2393 : +2394 str +2395 , +2396 str +2397 : +2398 str +2399 , +2400 str +2401 : +2402 str +2403 , +2404 str +2405 : +2406 str +2407 } +2408 , +2409 str +2410 : +2411 { +2412 str +2413 : +2414 str +2415 , +2416 str +2417 : +2418 str +2419 } +2420 } +2421 } +2422 , +2423 { +2424 str +2425 : +2426 str +2427 , +2428 str +2429 : +2430 { +2431 str +2432 : +2433 str +2434 , +2435 str +2436 : +2437 num +2438 , +2439 str +2440 : +2441 { +2442 str +2443 : +2444 num +2445 , +2446 str +2447 : +2448 num +2449 } +2450 , +2451 str +2452 : +2453 str +2454 , +2455 str +2456 : +2457 num +2458 , +2459 str +2460 : +2461 { +2462 str +2463 : +2464 num +2465 , +2466 str +2467 : +2468 str +2469 , +2470 str +2471 : +2472 str +2473 , +2474 str +2475 : +2476 str +2477 , +2478 str +2479 : +2480 str +2481 , +2482 str +2483 : +2484 str +2485 } +2486 , +2487 str +2488 : +2489 { +2490 str +2491 : +2492 str +2493 , +2494 str +2495 : +2496 str +2497 } +2498 } +2499 } +2500 , +2501 { +2502 str +2503 : +2504 str +2505 , +2506 str +2507 : +2508 { +2509 str +2510 : +2511 str +2512 , +2513 str +2514 : +2515 num +2516 , +2517 str +2518 : +2519 { +2520 str +2521 : +2522 num +2523 , +2524 str +2525 : +2526 num +2527 } +2528 , +2529 str +2530 : +2531 str +2532 , +2533 str +2534 : +2535 num +2536 , +2537 str +2538 : +2539 { +2540 str +2541 : +2542 num +2543 , +2544 str +2545 : +2546 str +2547 , +2548 str +2549 : +2550 str +2551 , +2552 str +2553 : +2554 str +2555 , +2556 str +2557 : +2558 str +2559 , +2560 str +2561 : +2562 str +2563 } +2564 , +2565 str +2566 : +2567 { +2568 str +2569 : +2570 str +2571 , +2572 str +2573 : +2574 str +2575 } +2576 } +2577 } +2578 , +2579 { +2580 str +2581 : +2582 str +2583 , +2584 str +2585 : +2586 { +2587 str +2588 : +2589 str +2590 , +2591 str +2592 : +2593 num +2594 , +2595 str +2596 : +2597 { +2598 str +2599 : +2600 num +2601 , +2602 str +2603 : +2604 num +2605 } +2606 , +2607 str +2608 : +2609 str +2610 , +2611 str +2612 : +2613 num +2614 , +2615 str +2616 : +2617 { +2618 str +2619 : +2620 num +2621 , +2622 str +2623 : +2624 str +2625 , +2626 str +2627 : +2628 str +2629 , +2630 str +2631 : +2632 str +2633 , +2634 str +2635 : +2636 str +2637 , +2638 str +2639 : +2640 str +2641 } +2642 , +2643 str +2644 : +2645 { +2646 str +2647 : +2648 str +2649 , +2650 str +2651 : +2652 str +2653 } +2654 } +2655 } +2656 , +2657 { +2658 str +2659 : +2660 str +2661 , +2662 str +2663 : +2664 { +2665 str +2666 : +2667 str +2668 , +2669 str +2670 : +2671 num +2672 , +2673 str +2674 : +2675 { +2676 str +2677 : +2678 num +2679 , +2680 str +2681 : +2682 num +2683 } +2684 , +2685 str +2686 : +2687 str +2688 , +2689 str +2690 : +2691 num +2692 , +2693 str +2694 : +2695 { +2696 str +2697 : +2698 num +2699 , +2700 str +2701 : +2702 str +2703 , +2704 str +2705 : +2706 str +2707 , +2708 str +2709 : +2710 str +2711 , +2712 str +2713 : +2714 str +2715 , +2716 str +2717 : +2718 str +2719 } +2720 , +2721 str +2722 : +2723 { +2724 str +2725 : +2726 str +2727 , +2728 str +2729 : +2730 str +2731 } +2732 } +2733 } +2734 , +2735 { +2736 str +2737 : +2738 str +2739 , +2740 str +2741 : +2742 { +2743 str +2744 : +2745 str +2746 , +2747 str +2748 : +2749 num +2750 , +2751 str +2752 : +2753 { +2754 str +2755 : +2756 num +2757 , +2758 str +2759 : +2760 num +2761 } +2762 , +2763 str +2764 : +2765 str +2766 , +2767 str +2768 : +2769 num +2770 , +2771 str +2772 : +2773 { +2774 str +2775 : +2776 num +2777 , +2778 str +2779 : +2780 str +2781 , +2782 str +2783 : +2784 str +2785 , +2786 str +2787 : +2788 str +2789 , +2790 str +2791 : +2792 str +2793 , +2794 str +2795 : +2796 str +2797 } +2798 , +2799 str +2800 : +2801 { +2802 str +2803 : +2804 str +2805 , +2806 str +2807 : +2808 str +2809 } +2810 } +2811 } +2812 , +2813 { +2814 str +2815 : +2816 str +2817 , +2818 str +2819 : +2820 { +2821 str +2822 : +2823 str +2824 , +2825 str +2826 : +2827 num +2828 , +2829 str +2830 : +2831 { +2832 str +2833 : +2834 num +2835 , +2836 str +2837 : +2838 num +2839 } +2840 , +2841 str +2842 : +2843 str +2844 , +2845 str +2846 : +2847 num +2848 , +2849 str +2850 : +2851 { +2852 str +2853 : +2854 num +2855 , +2856 str +2857 : +2858 str +2859 , +2860 str +2861 : +2862 str +2863 , +2864 str +2865 : +2866 str +2867 , +2868 str +2869 : +2870 str +2871 , +2872 str +2873 : +2874 str +2875 } +2876 , +2877 str +2878 : +2879 { +2880 str +2881 : +2882 str +2883 , +2884 str +2885 : +2886 str +2887 } +2888 } +2889 } +2890 , +2891 { +2892 str +2893 : +2894 str +2895 , +2896 str +2897 : +2898 { +2899 str +2900 : +2901 str +2902 , +2903 str +2904 : +2905 num +2906 , +2907 str +2908 : +2909 { +2910 str +2911 : +2912 num +2913 , +2914 str +2915 : +2916 num +2917 } +2918 , +2919 str +2920 : +2921 str +2922 , +2923 str +2924 : +2925 num +2926 , +2927 str +2928 : +2929 { +2930 str +2931 : +2932 num +2933 , +2934 str +2935 : +2936 str +2937 , +2938 str +2939 : +2940 str +2941 , +2942 str +2943 : +2944 str +2945 , +2946 str +2947 : +2948 str +2949 , +2950 str +2951 : +2952 str +2953 } +2954 , +2955 str +2956 : +2957 { +2958 str +2959 : +2960 str +2961 , +2962 str +2963 : +2964 str +2965 } +2966 } +2967 } +2968 , +2969 { +2970 str +2971 : +2972 str +2973 , +2974 str +2975 : +2976 { +2977 str +2978 : +2979 str +2980 , +2981 str +2982 : +2983 num +2984 , +2985 str +2986 : +2987 { +2988 str +2989 : +2990 num +2991 , +2992 str +2993 : +2994 num +2995 } +2996 , +2997 str +2998 : +2999 str +3000 , +3001 str +3002 : +3003 num +3004 , +3005 str +3006 : +3007 { +3008 str +3009 : +3010 num +3011 , +3012 str +3013 : +3014 str +3015 , +3016 str +3017 : +3018 str +3019 , +3020 str +3021 : +3022 str +3023 , +3024 str +3025 : +3026 str +3027 , +3028 str +3029 : +3030 str +3031 } +3032 , +3033 str +3034 : +3035 { +3036 str +3037 : +3038 str +3039 , +3040 str +3041 : +3042 str +3043 } +3044 } +3045 } +3046 , +3047 { +3048 str +3049 : +3050 str +3051 , +3052 str +3053 : +3054 { +3055 str +3056 : +3057 str +3058 , +3059 str +3060 : +3061 num +3062 , +3063 str +3064 : +3065 { +3066 str +3067 : +3068 num +3069 , +3070 str +3071 : +3072 num +3073 } +3074 , +3075 str +3076 : +3077 str +3078 , +3079 str +3080 : +3081 num +3082 , +3083 str +3084 : +3085 { +3086 str +3087 : +3088 num +3089 , +3090 str +3091 : +3092 str +3093 , +3094 str +3095 : +3096 str +3097 , +3098 str +3099 : +3100 str +3101 , +3102 str +3103 : +3104 str +3105 , +3106 str +3107 : +3108 str +3109 } +3110 , +3111 str +3112 : +3113 { +3114 str +3115 : +3116 str +3117 , +3118 str +3119 : +3120 str +3121 } +3122 } +3123 } +3124 , +3125 { +3126 str +3127 : +3128 str +3129 , +3130 str +3131 : +3132 { +3133 str +3134 : +3135 str +3136 , +3137 str +3138 : +3139 num +3140 , +3141 str +3142 : +3143 { +3144 str +3145 : +3146 num +3147 , +3148 str +3149 : +3150 num +3151 } +3152 , +3153 str +3154 : +3155 str +3156 , +3157 str +3158 : +3159 num +3160 , +3161 str +3162 : +3163 { +3164 str +3165 : +3166 num +3167 , +3168 str +3169 : +3170 str +3171 , +3172 str +3173 : +3174 str +3175 , +3176 str +3177 : +3178 str +3179 , +3180 str +3181 : +3182 str +3183 , +3184 str +3185 : +3186 str +3187 } +3188 , +3189 str +3190 : +3191 { +3192 str +3193 : +3194 str +3195 , +3196 str +3197 : +3198 str +3199 } +3200 } +3201 } +3202 , +3203 { +3204 str +3205 : +3206 str +3207 , +3208 str +3209 : +3210 { +3211 str +3212 : +3213 str +3214 , +3215 str +3216 : +3217 num +3218 , +3219 str +3220 : +3221 { +3222 str +3223 : +3224 num +3225 , +3226 str +3227 : +3228 num +3229 } +3230 , +3231 str +3232 : +3233 str +3234 , +3235 str +3236 : +3237 num +3238 , +3239 str +3240 : +3241 { +3242 str +3243 : +3244 num +3245 , +3246 str +3247 : +3248 str +3249 , +3250 str +3251 : +3252 str +3253 , +3254 str +3255 : +3256 str +3257 , +3258 str +3259 : +3260 str +3261 , +3262 str +3263 : +3264 str +3265 } +3266 , +3267 str +3268 : +3269 { +3270 str +3271 : +3272 str +3273 , +3274 str +3275 : +3276 str +3277 } +3278 } +3279 } +3280 , +3281 { +3282 str +3283 : +3284 str +3285 , +3286 str +3287 : +3288 { +3289 str +3290 : +3291 str +3292 , +3293 str +3294 : +3295 num +3296 , +3297 str +3298 : +3299 { +3300 str +3301 : +3302 num +3303 , +3304 str +3305 : +3306 num +3307 } +3308 , +3309 str +3310 : +3311 str +3312 , +3313 str +3314 : +3315 num +3316 , +3317 str +3318 : +3319 { +3320 str +3321 : +3322 num +3323 , +3324 str +3325 : +3326 str +3327 , +3328 str +3329 : +3330 str +3331 , +3332 str +3333 : +3334 str +3335 , +3336 str +3337 : +3338 str +3339 , +3340 str +3341 : +3342 str +3343 } +3344 , +3345 str +3346 : +3347 { +3348 str +3349 : +3350 str +3351 , +3352 str +3353 : +3354 str +3355 } +3356 } +3357 } +3358 , +3359 { +3360 str +3361 : +3362 str +3363 , +3364 str +3365 : +3366 { +3367 str +3368 : +3369 str +3370 , +3371 str +3372 : +3373 num +3374 , +3375 str +3376 : +3377 { +3378 str +3379 : +3380 num +3381 , +3382 str +3383 : +3384 num +3385 } +3386 , +3387 str +3388 : +3389 str +3390 , +3391 str +3392 : +3393 num +3394 , +3395 str +3396 : +3397 { +3398 str +3399 : +3400 num +3401 , +3402 str +3403 : +3404 str +3405 , +3406 str +3407 : +3408 str +3409 , +3410 str +3411 : +3412 str +3413 , +3414 str +3415 : +3416 str +3417 , +3418 str +3419 : +3420 str +3421 } +3422 , +3423 str +3424 : +3425 { +3426 str +3427 : +3428 str +3429 , +3430 str +3431 : +3432 str +3433 } +3434 } +3435 } +3436 , +3437 { +3438 str +3439 : +3440 str +3441 , +3442 str +3443 : +3444 { +3445 str +3446 : +3447 str +3448 , +3449 str +3450 : +3451 num +3452 , +3453 str +3454 : +3455 { +3456 str +3457 : +3458 num +3459 , +3460 str +3461 : +3462 num +3463 } +3464 , +3465 str +3466 : +3467 str +3468 , +3469 str +3470 : +3471 num +3472 , +3473 str +3474 : +3475 { +3476 str +3477 : +3478 num +3479 , +3480 str +3481 : +3482 str +3483 , +3484 str +3485 : +3486 str +3487 , +3488 str +3489 : +3490 str +3491 , +3492 str +3493 : +3494 str +3495 , +3496 str +3497 : +3498 str +3499 } +3500 , +3501 str +3502 : +3503 { +3504 str +3505 : +3506 str +3507 , +3508 str +3509 : +3510 str +3511 } +3512 } +3513 } +3514 , +3515 { +3516 str +3517 : +3518 str +3519 , +3520 str +3521 : +3522 { +3523 str +3524 : +3525 str +3526 , +3527 str +3528 : +3529 num +3530 , +3531 str +3532 : +3533 { +3534 str +3535 : +3536 num +3537 , +3538 str +3539 : +3540 num +3541 } +3542 , +3543 str +3544 : +3545 str +3546 , +3547 str +3548 : +3549 num +3550 , +3551 str +3552 : +3553 { +3554 str +3555 : +3556 num +3557 , +3558 str +3559 : +3560 str +3561 , +3562 str +3563 : +3564 str +3565 , +3566 str +3567 : +3568 str +3569 , +3570 str +3571 : +3572 str +3573 , +3574 str +3575 : +3576 str +3577 } +3578 , +3579 str +3580 : +3581 { +3582 str +3583 : +3584 str +3585 , +3586 str +3587 : +3588 str +3589 } +3590 } +3591 } +3592 , +3593 { +3594 str +3595 : +3596 str +3597 , +3598 str +3599 : +3600 { +3601 str +3602 : +3603 str +3604 , +3605 str +3606 : +3607 num +3608 , +3609 str +3610 : +3611 { +3612 str +3613 : +3614 num +3615 , +3616 str +3617 : +3618 num +3619 } +3620 , +3621 str +3622 : +3623 str +3624 , +3625 str +3626 : +3627 num +3628 , +3629 str +3630 : +3631 { +3632 str +3633 : +3634 num +3635 , +3636 str +3637 : +3638 str +3639 , +3640 str +3641 : +3642 str +3643 , +3644 str +3645 : +3646 str +3647 , +3648 str +3649 : +3650 str +3651 , +3652 str +3653 : +3654 str +3655 } +3656 , +3657 str +3658 : +3659 { +3660 str +3661 : +3662 str +3663 , +3664 str +3665 : +3666 str +3667 } +3668 } +3669 } +3670 , +3671 { +3672 str +3673 : +3674 str +3675 , +3676 str +3677 : +3678 { +3679 str +3680 : +3681 str +3682 , +3683 str +3684 : +3685 num +3686 , +3687 str +3688 : +3689 { +3690 str +3691 : +3692 num +3693 , +3694 str +3695 : +3696 num +3697 } +3698 , +3699 str +3700 : +3701 str +3702 , +3703 str +3704 : +3705 num +3706 , +3707 str +3708 : +3709 { +3710 str +3711 : +3712 num +3713 , +3714 str +3715 : +3716 str +3717 , +3718 str +3719 : +3720 str +3721 , +3722 str +3723 : +3724 str +3725 , +3726 str +3727 : +3728 str +3729 , +3730 str +3731 : +3732 str +3733 } +3734 , +3735 str +3736 : +3737 { +3738 str +3739 : +3740 str +3741 , +3742 str +3743 : +3744 str +3745 } +3746 } +3747 } +3748 , +3749 { +3750 str +3751 : +3752 str +3753 , +3754 str +3755 : +3756 { +3757 str +3758 : +3759 str +3760 , +3761 str +3762 : +3763 num +3764 , +3765 str +3766 : +3767 { +3768 str +3769 : +3770 num +3771 , +3772 str +3773 : +3774 num +3775 } +3776 , +3777 str +3778 : +3779 str +3780 , +3781 str +3782 : +3783 num +3784 , +3785 str +3786 : +3787 { +3788 str +3789 : +3790 num +3791 , +3792 str +3793 : +3794 str +3795 , +3796 str +3797 : +3798 str +3799 , +3800 str +3801 : +3802 str +3803 , +3804 str +3805 : +3806 str +3807 , +3808 str +3809 : +3810 str +3811 } +3812 , +3813 str +3814 : +3815 { +3816 str +3817 : +3818 str +3819 , +3820 str +3821 : +3822 str +3823 } +3824 } +3825 } +3826 , +3827 { +3828 str +3829 : +3830 str +3831 , +3832 str +3833 : +3834 { +3835 str +3836 : +3837 str +3838 , +3839 str +3840 : +3841 num +3842 , +3843 str +3844 : +3845 { +3846 str +3847 : +3848 num +3849 , +3850 str +3851 : +3852 num +3853 } +3854 , +3855 str +3856 : +3857 str +3858 , +3859 str +3860 : +3861 num +3862 , +3863 str +3864 : +3865 { +3866 str +3867 : +3868 num +3869 , +3870 str +3871 : +3872 str +3873 , +3874 str +3875 : +3876 str +3877 , +3878 str +3879 : +3880 str +3881 , +3882 str +3883 : +3884 str +3885 , +3886 str +3887 : +3888 str +3889 } +3890 , +3891 str +3892 : +3893 { +3894 str +3895 : +3896 str +3897 , +3898 str +3899 : +3900 str +3901 } +3902 } +3903 } +3904 , +3905 { +3906 str +3907 : +3908 str +3909 , +3910 str +3911 : +3912 { +3913 str +3914 : +3915 str +3916 , +3917 str +3918 : +3919 num +3920 , +3921 str +3922 : +3923 { +3924 str +3925 : +3926 num +3927 , +3928 str +3929 : +3930 num +3931 } +3932 , +3933 str +3934 : +3935 str +3936 , +3937 str +3938 : +3939 num +3940 , +3941 str +3942 : +3943 { +3944 str +3945 : +3946 num +3947 , +3948 str +3949 : +3950 str +3951 , +3952 str +3953 : +3954 str +3955 , +3956 str +3957 : +3958 str +3959 , +3960 str +3961 : +3962 str +3963 , +3964 str +3965 : +3966 str +3967 } +3968 , +3969 str +3970 : +3971 { +3972 str +3973 : +3974 str +3975 , +3976 str +3977 : +3978 str +3979 } +3980 } +3981 } +3982 , +3983 { +3984 str +3985 : +3986 str +3987 , +3988 str +3989 : +3990 { +3991 str +3992 : +3993 str +3994 , +3995 str +3996 : +3997 num +3998 , +3999 str +4000 : +4001 { +4002 str +4003 : +4004 num +4005 , +4006 str +4007 : +4008 num +4009 } +4010 , +4011 str +4012 : +4013 str +4014 , +4015 str +4016 : +4017 num +4018 , +4019 str +4020 : +4021 { +4022 str +4023 : +4024 num +4025 , +4026 str +4027 : +4028 str +4029 , +4030 str +4031 : +4032 str +4033 , +4034 str +4035 : +4036 str +4037 , +4038 str +4039 : +4040 str +4041 , +4042 str +4043 : +4044 str +4045 } +4046 , +4047 str +4048 : +4049 { +4050 str +4051 : +4052 str +4053 , +4054 str +4055 : +4056 str +4057 } +4058 } +4059 } +4060 , +4061 { +4062 str +4063 : +4064 str +4065 , +4066 str +4067 : +4068 { +4069 str +4070 : +4071 str +4072 , +4073 str +4074 : +4075 num +4076 , +4077 str +4078 : +4079 { +4080 str +4081 : +4082 num +4083 , +4084 str +4085 : +4086 num +4087 } +4088 , +4089 str +4090 : +4091 str +4092 , +4093 str +4094 : +4095 num +4096 , +4097 str +4098 : +4099 { +4100 str +4101 : +4102 num +4103 , +4104 str +4105 : +4106 str +4107 , +4108 str +4109 : +4110 str +4111 , +4112 str +4113 : +4114 str +4115 , +4116 str +4117 : +4118 str +4119 , +4120 str +4121 : +4122 str +4123 } +4124 , +4125 str +4126 : +4127 { +4128 str +4129 : +4130 str +4131 , +4132 str +4133 : +4134 str +4135 } +4136 } +4137 } +4138 , +4139 { +4140 str +4141 : +4142 str +4143 , +4144 str +4145 : +4146 { +4147 str +4148 : +4149 str +4150 , +4151 str +4152 : +4153 num +4154 , +4155 str +4156 : +4157 { +4158 str +4159 : +4160 num +4161 , +4162 str +4163 : +4164 num +4165 } +4166 , +4167 str +4168 : +4169 str +4170 , +4171 str +4172 : +4173 num +4174 , +4175 str +4176 : +4177 { +4178 str +4179 : +4180 num +4181 , +4182 str +4183 : +4184 str +4185 , +4186 str +4187 : +4188 str +4189 , +4190 str +4191 : +4192 str +4193 , +4194 str +4195 : +4196 str +4197 , +4198 str +4199 : +4200 str +4201 } +4202 , +4203 str +4204 : +4205 { +4206 str +4207 : +4208 str +4209 , +4210 str +4211 : +4212 str +4213 } +4214 } +4215 } +4216 , +4217 { +4218 str +4219 : +4220 str +4221 , +4222 str +4223 : +4224 { +4225 str +4226 : +4227 str +4228 , +4229 str +4230 : +4231 num +4232 , +4233 str +4234 : +4235 { +4236 str +4237 : +4238 num +4239 , +4240 str +4241 : +4242 num +4243 } +4244 , +4245 str +4246 : +4247 str +4248 , +4249 str +4250 : +4251 num +4252 , +4253 str +4254 : +4255 { +4256 str +4257 : +4258 num +4259 , +4260 str +4261 : +4262 str +4263 , +4264 str +4265 : +4266 str +4267 , +4268 str +4269 : +4270 str +4271 , +4272 str +4273 : +4274 str +4275 , +4276 str +4277 : +4278 str +4279 } +4280 , +4281 str +4282 : +4283 { +4284 str +4285 : +4286 str +4287 , +4288 str +4289 : +4290 str +4291 } +4292 } +4293 } +4294 , +4295 { +4296 str +4297 : +4298 str +4299 , +4300 str +4301 : +4302 { +4303 str +4304 : +4305 str +4306 , +4307 str +4308 : +4309 num +4310 , +4311 str +4312 : +4313 { +4314 str +4315 : +4316 num +4317 , +4318 str +4319 : +4320 num +4321 } +4322 , +4323 str +4324 : +4325 str +4326 , +4327 str +4328 : +4329 num +4330 , +4331 str +4332 : +4333 { +4334 str +4335 : +4336 num +4337 , +4338 str +4339 : +4340 str +4341 , +4342 str +4343 : +4344 str +4345 , +4346 str +4347 : +4348 str +4349 , +4350 str +4351 : +4352 str +4353 , +4354 str +4355 : +4356 str +4357 } +4358 , +4359 str +4360 : +4361 { +4362 str +4363 : +4364 str +4365 , +4366 str +4367 : +4368 str +4369 } +4370 } +4371 } +4372 , +4373 { +4374 str +4375 : +4376 str +4377 , +4378 str +4379 : +4380 { +4381 str +4382 : +4383 str +4384 , +4385 str +4386 : +4387 num +4388 , +4389 str +4390 : +4391 { +4392 str +4393 : +4394 num +4395 , +4396 str +4397 : +4398 num +4399 } +4400 , +4401 str +4402 : +4403 str +4404 , +4405 str +4406 : +4407 num +4408 , +4409 str +4410 : +4411 { +4412 str +4413 : +4414 num +4415 , +4416 str +4417 : +4418 str +4419 , +4420 str +4421 : +4422 str +4423 , +4424 str +4425 : +4426 str +4427 , +4428 str +4429 : +4430 str +4431 , +4432 str +4433 : +4434 str +4435 } +4436 , +4437 str +4438 : +4439 { +4440 str +4441 : +4442 str +4443 , +4444 str +4445 : +4446 str +4447 } +4448 } +4449 } +4450 , +4451 { +4452 str +4453 : +4454 str +4455 , +4456 str +4457 : +4458 { +4459 str +4460 : +4461 str +4462 , +4463 str +4464 : +4465 num +4466 , +4467 str +4468 : +4469 { +4470 str +4471 : +4472 num +4473 , +4474 str +4475 : +4476 num +4477 } +4478 , +4479 str +4480 : +4481 str +4482 , +4483 str +4484 : +4485 num +4486 , +4487 str +4488 : +4489 { +4490 str +4491 : +4492 num +4493 , +4494 str +4495 : +4496 str +4497 , +4498 str +4499 : +4500 str +4501 , +4502 str +4503 : +4504 str +4505 , +4506 str +4507 : +4508 str +4509 , +4510 str +4511 : +4512 str +4513 } +4514 , +4515 str +4516 : +4517 { +4518 str +4519 : +4520 str +4521 , +4522 str +4523 : +4524 str +4525 } +4526 } +4527 } +4528 , +4529 { +4530 str +4531 : +4532 str +4533 , +4534 str +4535 : +4536 { +4537 str +4538 : +4539 str +4540 , +4541 str +4542 : +4543 num +4544 , +4545 str +4546 : +4547 { +4548 str +4549 : +4550 num +4551 , +4552 str +4553 : +4554 num +4555 } +4556 , +4557 str +4558 : +4559 str +4560 , +4561 str +4562 : +4563 num +4564 , +4565 str +4566 : +4567 { +4568 str +4569 : +4570 num +4571 , +4572 str +4573 : +4574 str +4575 , +4576 str +4577 : +4578 str +4579 , +4580 str +4581 : +4582 str +4583 , +4584 str +4585 : +4586 str +4587 , +4588 str +4589 : +4590 str +4591 } +4592 , +4593 str +4594 : +4595 { +4596 str +4597 : +4598 str +4599 , +4600 str +4601 : +4602 str +4603 } +4604 } +4605 } +4606 , +4607 { +4608 str +4609 : +4610 str +4611 , +4612 str +4613 : +4614 { +4615 str +4616 : +4617 str +4618 , +4619 str +4620 : +4621 num +4622 , +4623 str +4624 : +4625 { +4626 str +4627 : +4628 num +4629 , +4630 str +4631 : +4632 num +4633 } +4634 , +4635 str +4636 : +4637 str +4638 , +4639 str +4640 : +4641 num +4642 , +4643 str +4644 : +4645 { +4646 str +4647 : +4648 num +4649 , +4650 str +4651 : +4652 str +4653 , +4654 str +4655 : +4656 str +4657 , +4658 str +4659 : +4660 str +4661 , +4662 str +4663 : +4664 str +4665 , +4666 str +4667 : +4668 str +4669 } +4670 , +4671 str +4672 : +4673 { +4674 str +4675 : +4676 str +4677 , +4678 str +4679 : +4680 str +4681 } +4682 } +4683 } +4684 , +4685 { +4686 str +4687 : +4688 str +4689 , +4690 str +4691 : +4692 { +4693 str +4694 : +4695 str +4696 , +4697 str +4698 : +4699 num +4700 , +4701 str +4702 : +4703 { +4704 str +4705 : +4706 num +4707 , +4708 str +4709 : +4710 num +4711 } +4712 , +4713 str +4714 : +4715 str +4716 , +4717 str +4718 : +4719 num +4720 , +4721 str +4722 : +4723 { +4724 str +4725 : +4726 num +4727 , +4728 str +4729 : +4730 str +4731 , +4732 str +4733 : +4734 str +4735 , +4736 str +4737 : +4738 str +4739 , +4740 str +4741 : +4742 str +4743 , +4744 str +4745 : +4746 str +4747 } +4748 , +4749 str +4750 : +4751 { +4752 str +4753 : +4754 str +4755 , +4756 str +4757 : +4758 str +4759 } +4760 } +4761 } +4762 , +4763 { +4764 str +4765 : +4766 str +4767 , +4768 str +4769 : +4770 { +4771 str +4772 : +4773 str +4774 , +4775 str +4776 : +4777 num +4778 , +4779 str +4780 : +4781 { +4782 str +4783 : +4784 num +4785 , +4786 str +4787 : +4788 num +4789 } +4790 , +4791 str +4792 : +4793 str +4794 , +4795 str +4796 : +4797 num +4798 , +4799 str +4800 : +4801 { +4802 str +4803 : +4804 num +4805 , +4806 str +4807 : +4808 str +4809 , +4810 str +4811 : +4812 str +4813 , +4814 str +4815 : +4816 str +4817 , +4818 str +4819 : +4820 str +4821 , +4822 str +4823 : +4824 str +4825 } +4826 , +4827 str +4828 : +4829 { +4830 str +4831 : +4832 str +4833 , +4834 str +4835 : +4836 str +4837 } +4838 } +4839 } +4840 , +4841 { +4842 str +4843 : +4844 str +4845 , +4846 str +4847 : +4848 { +4849 str +4850 : +4851 str +4852 , +4853 str +4854 : +4855 num +4856 , +4857 str +4858 : +4859 { +4860 str +4861 : +4862 num +4863 , +4864 str +4865 : +4866 num +4867 } +4868 , +4869 str +4870 : +4871 str +4872 , +4873 str +4874 : +4875 num +4876 , +4877 str +4878 : +4879 { +4880 str +4881 : +4882 num +4883 , +4884 str +4885 : +4886 str +4887 , +4888 str +4889 : +4890 str +4891 , +4892 str +4893 : +4894 str +4895 , +4896 str +4897 : +4898 str +4899 , +4900 str +4901 : +4902 str +4903 } +4904 , +4905 str +4906 : +4907 { +4908 str +4909 : +4910 str +4911 , +4912 str +4913 : +4914 str +4915 } +4916 } +4917 } +4918 , +4919 { +4920 str +4921 : +4922 str +4923 , +4924 str +4925 : +4926 { +4927 str +4928 : +4929 str +4930 , +4931 str +4932 : +4933 num +4934 , +4935 str +4936 : +4937 { +4938 str +4939 : +4940 num +4941 , +4942 str +4943 : +4944 num +4945 } +4946 , +4947 str +4948 : +4949 str +4950 , +4951 str +4952 : +4953 num +4954 , +4955 str +4956 : +4957 { +4958 str +4959 : +4960 num +4961 , +4962 str +4963 : +4964 str +4965 , +4966 str +4967 : +4968 str +4969 , +4970 str +4971 : +4972 str +4973 , +4974 str +4975 : +4976 str +4977 , +4978 str +4979 : +4980 str +4981 } +4982 , +4983 str +4984 : +4985 { +4986 str +4987 : +4988 str +4989 , +4990 str +4991 : +4992 str +4993 } +4994 } +4995 } +4996 , +4997 { +4998 str +4999 : +5000 str +5001 , +5002 str +5003 : +5004 { +5005 str +5006 : +5007 str +5008 , +5009 str +5010 : +5011 num +5012 , +5013 str +5014 : +5015 { +5016 str +5017 : +5018 num +5019 , +5020 str +5021 : +5022 num +5023 } +5024 , +5025 str +5026 : +5027 str +5028 , +5029 str +5030 : +5031 num +5032 , +5033 str +5034 : +5035 { +5036 str +5037 : +5038 num +5039 , +5040 str +5041 : +5042 str +5043 , +5044 str +5045 : +5046 str +5047 , +5048 str +5049 : +5050 str +5051 , +5052 str +5053 : +5054 str +5055 , +5056 str +5057 : +5058 str +5059 } +5060 , +5061 str +5062 : +5063 { +5064 str +5065 : +5066 str +5067 , +5068 str +5069 : +5070 str +5071 } +5072 } +5073 } +5074 , +5075 { +5076 str +5077 : +5078 str +5079 , +5080 str +5081 : +5082 { +5083 str +5084 : +5085 str +5086 , +5087 str +5088 : +5089 num +5090 , +5091 str +5092 : +5093 { +5094 str +5095 : +5096 num +5097 , +5098 str +5099 : +5100 num +5101 } +5102 , +5103 str +5104 : +5105 str +5106 , +5107 str +5108 : +5109 num +5110 , +5111 str +5112 : +5113 { +5114 str +5115 : +5116 num +5117 , +5118 str +5119 : +5120 str +5121 , +5122 str +5123 : +5124 str +5125 , +5126 str +5127 : +5128 str +5129 , +5130 str +5131 : +5132 str +5133 , +5134 str +5135 : +5136 str +5137 } +5138 , +5139 str +5140 : +5141 { +5142 str +5143 : +5144 str +5145 , +5146 str +5147 : +5148 str +5149 } +5150 } +5151 } +5152 , +5153 { +5154 str +5155 : +5156 str +5157 , +5158 str +5159 : +5160 { +5161 str +5162 : +5163 str +5164 , +5165 str +5166 : +5167 num +5168 , +5169 str +5170 : +5171 { +5172 str +5173 : +5174 num +5175 , +5176 str +5177 : +5178 num +5179 } +5180 , +5181 str +5182 : +5183 str +5184 , +5185 str +5186 : +5187 num +5188 , +5189 str +5190 : +5191 { +5192 str +5193 : +5194 num +5195 , +5196 str +5197 : +5198 str +5199 , +5200 str +5201 : +5202 str +5203 , +5204 str +5205 : +5206 str +5207 , +5208 str +5209 : +5210 str +5211 , +5212 str +5213 : +5214 str +5215 } +5216 , +5217 str +5218 : +5219 { +5220 str +5221 : +5222 str +5223 , +5224 str +5225 : +5226 str +5227 } +5228 } +5229 } +5230 , +5231 { +5232 str +5233 : +5234 str +5235 , +5236 str +5237 : +5238 { +5239 str +5240 : +5241 str +5242 , +5243 str +5244 : +5245 num +5246 , +5247 str +5248 : +5249 { +5250 str +5251 : +5252 num +5253 , +5254 str +5255 : +5256 num +5257 } +5258 , +5259 str +5260 : +5261 str +5262 , +5263 str +5264 : +5265 num +5266 , +5267 str +5268 : +5269 { +5270 str +5271 : +5272 num +5273 , +5274 str +5275 : +5276 str +5277 , +5278 str +5279 : +5280 str +5281 , +5282 str +5283 : +5284 str +5285 , +5286 str +5287 : +5288 str +5289 , +5290 str +5291 : +5292 str +5293 } +5294 , +5295 str +5296 : +5297 { +5298 str +5299 : +5300 str +5301 , +5302 str +5303 : +5304 str +5305 } +5306 } +5307 } +5308 , +5309 { +5310 str +5311 : +5312 str +5313 , +5314 str +5315 : +5316 { +5317 str +5318 : +5319 str +5320 , +5321 str +5322 : +5323 num +5324 , +5325 str +5326 : +5327 { +5328 str +5329 : +5330 num +5331 , +5332 str +5333 : +5334 num +5335 } +5336 , +5337 str +5338 : +5339 str +5340 , +5341 str +5342 : +5343 num +5344 , +5345 str +5346 : +5347 { +5348 str +5349 : +5350 num +5351 , +5352 str +5353 : +5354 str +5355 , +5356 str +5357 : +5358 str +5359 , +5360 str +5361 : +5362 str +5363 , +5364 str +5365 : +5366 str +5367 , +5368 str +5369 : +5370 str +5371 } +5372 , +5373 str +5374 : +5375 { +5376 str +5377 : +5378 str +5379 , +5380 str +5381 : +5382 str +5383 } +5384 } +5385 } +5386 , +5387 { +5388 str +5389 : +5390 str +5391 , +5392 str +5393 : +5394 { +5395 str +5396 : +5397 str +5398 , +5399 str +5400 : +5401 num +5402 , +5403 str +5404 : +5405 { +5406 str +5407 : +5408 num +5409 , +5410 str +5411 : +5412 num +5413 } +5414 , +5415 str +5416 : +5417 str +5418 , +5419 str +5420 : +5421 num +5422 , +5423 str +5424 : +5425 { +5426 str +5427 : +5428 num +5429 , +5430 str +5431 : +5432 str +5433 , +5434 str +5435 : +5436 str +5437 , +5438 str +5439 : +5440 str +5441 , +5442 str +5443 : +5444 str +5445 , +5446 str +5447 : +5448 str +5449 } +5450 , +5451 str +5452 : +5453 { +5454 str +5455 : +5456 str +5457 , +5458 str +5459 : +5460 str +5461 } +5462 } +5463 } +5464 , +5465 { +5466 str +5467 : +5468 str +5469 , +5470 str +5471 : +5472 { +5473 str +5474 : +5475 str +5476 , +5477 str +5478 : +5479 num +5480 , +5481 str +5482 : +5483 { +5484 str +5485 : +5486 num +5487 , +5488 str +5489 : +5490 num +5491 } +5492 , +5493 str +5494 : +5495 str +5496 , +5497 str +5498 : +5499 num +5500 , +5501 str +5502 : +5503 { +5504 str +5505 : +5506 num +5507 , +5508 str +5509 : +5510 str +5511 , +5512 str +5513 : +5514 str +5515 , +5516 str +5517 : +5518 str +5519 , +5520 str +5521 : +5522 str +5523 , +5524 str +5525 : +5526 str +5527 } +5528 , +5529 str +5530 : +5531 { +5532 str +5533 : +5534 str +5535 , +5536 str +5537 : +5538 str +5539 } +5540 } +5541 } +5542 , +5543 { +5544 str +5545 : +5546 str +5547 , +5548 str +5549 : +5550 { +5551 str +5552 : +5553 str +5554 , +5555 str +5556 : +5557 num +5558 , +5559 str +5560 : +5561 { +5562 str +5563 : +5564 num +5565 , +5566 str +5567 : +5568 num +5569 } +5570 , +5571 str +5572 : +5573 str +5574 , +5575 str +5576 : +5577 num +5578 , +5579 str +5580 : +5581 { +5582 str +5583 : +5584 num +5585 , +5586 str +5587 : +5588 str +5589 , +5590 str +5591 : +5592 str +5593 , +5594 str +5595 : +5596 str +5597 , +5598 str +5599 : +5600 str +5601 , +5602 str +5603 : +5604 str +5605 } +5606 , +5607 str +5608 : +5609 { +5610 str +5611 : +5612 str +5613 , +5614 str +5615 : +5616 str +5617 } +5618 } +5619 } +5620 , +5621 { +5622 str +5623 : +5624 str +5625 , +5626 str +5627 : +5628 { +5629 str +5630 : +5631 str +5632 , +5633 str +5634 : +5635 num +5636 , +5637 str +5638 : +5639 { +5640 str +5641 : +5642 num +5643 , +5644 str +5645 : +5646 num +5647 } +5648 , +5649 str +5650 : +5651 str +5652 , +5653 str +5654 : +5655 num +5656 , +5657 str +5658 : +5659 { +5660 str +5661 : +5662 num +5663 , +5664 str +5665 : +5666 str +5667 , +5668 str +5669 : +5670 str +5671 , +5672 str +5673 : +5674 str +5675 , +5676 str +5677 : +5678 str +5679 , +5680 str +5681 : +5682 str +5683 } +5684 , +5685 str +5686 : +5687 { +5688 str +5689 : +5690 str +5691 , +5692 str +5693 : +5694 str +5695 } +5696 } +5697 } +5698 , +5699 { +5700 str +5701 : +5702 str +5703 , +5704 str +5705 : +5706 { +5707 str +5708 : +5709 str +5710 , +5711 str +5712 : +5713 num +5714 , +5715 str +5716 : +5717 { +5718 str +5719 : +5720 num +5721 , +5722 str +5723 : +5724 num +5725 } +5726 , +5727 str +5728 : +5729 str +5730 , +5731 str +5732 : +5733 num +5734 , +5735 str +5736 : +5737 { +5738 str +5739 : +5740 num +5741 , +5742 str +5743 : +5744 str +5745 , +5746 str +5747 : +5748 str +5749 , +5750 str +5751 : +5752 str +5753 , +5754 str +5755 : +5756 str +5757 , +5758 str +5759 : +5760 str +5761 } +5762 , +5763 str +5764 : +5765 { +5766 str +5767 : +5768 str +5769 , +5770 str +5771 : +5772 str +5773 } +5774 } +5775 } +5776 , +5777 { +5778 str +5779 : +5780 str +5781 , +5782 str +5783 : +5784 { +5785 str +5786 : +5787 str +5788 , +5789 str +5790 : +5791 num +5792 , +5793 str +5794 : +5795 { +5796 str +5797 : +5798 num +5799 , +5800 str +5801 : +5802 num +5803 } +5804 , +5805 str +5806 : +5807 str +5808 , +5809 str +5810 : +5811 num +5812 , +5813 str +5814 : +5815 { +5816 str +5817 : +5818 num +5819 , +5820 str +5821 : +5822 str +5823 , +5824 str +5825 : +5826 str +5827 , +5828 str +5829 : +5830 str +5831 , +5832 str +5833 : +5834 str +5835 , +5836 str +5837 : +5838 str +5839 } +5840 , +5841 str +5842 : +5843 { +5844 str +5845 : +5846 str +5847 , +5848 str +5849 : +5850 str +5851 } +5852 } +5853 } +5854 , +5855 { +5856 str +5857 : +5858 str +5859 , +5860 str +5861 : +5862 { +5863 str +5864 : +5865 str +5866 , +5867 str +5868 : +5869 num +5870 , +5871 str +5872 : +5873 { +5874 str +5875 : +5876 num +5877 , +5878 str +5879 : +5880 num +5881 } +5882 , +5883 str +5884 : +5885 str +5886 , +5887 str +5888 : +5889 num +5890 , +5891 str +5892 : +5893 { +5894 str +5895 : +5896 num +5897 , +5898 str +5899 : +5900 str +5901 , +5902 str +5903 : +5904 str +5905 , +5906 str +5907 : +5908 str +5909 , +5910 str +5911 : +5912 str +5913 , +5914 str +5915 : +5916 str +5917 } +5918 , +5919 str +5920 : +5921 { +5922 str +5923 : +5924 str +5925 , +5926 str +5927 : +5928 str +5929 } +5930 } +5931 } +5932 , +5933 { +5934 str +5935 : +5936 str +5937 , +5938 str +5939 : +5940 { +5941 str +5942 : +5943 str +5944 , +5945 str +5946 : +5947 num +5948 , +5949 str +5950 : +5951 { +5952 str +5953 : +5954 num +5955 , +5956 str +5957 : +5958 num +5959 } +5960 , +5961 str +5962 : +5963 str +5964 , +5965 str +5966 : +5967 num +5968 , +5969 str +5970 : +5971 { +5972 str +5973 : +5974 num +5975 , +5976 str +5977 : +5978 str +5979 , +5980 str +5981 : +5982 str +5983 , +5984 str +5985 : +5986 str +5987 , +5988 str +5989 : +5990 str +5991 , +5992 str +5993 : +5994 str +5995 } +5996 , +5997 str +5998 : +5999 { +6000 str +6001 : +6002 str +6003 , +6004 str +6005 : +6006 str +6007 } +6008 } +6009 } +6010 , +6011 { +6012 str +6013 : +6014 str +6015 , +6016 str +6017 : +6018 { +6019 str +6020 : +6021 str +6022 , +6023 str +6024 : +6025 num +6026 , +6027 str +6028 : +6029 { +6030 str +6031 : +6032 num +6033 , +6034 str +6035 : +6036 num +6037 } +6038 , +6039 str +6040 : +6041 str +6042 , +6043 str +6044 : +6045 num +6046 , +6047 str +6048 : +6049 { +6050 str +6051 : +6052 num +6053 , +6054 str +6055 : +6056 str +6057 , +6058 str +6059 : +6060 str +6061 , +6062 str +6063 : +6064 str +6065 , +6066 str +6067 : +6068 str +6069 , +6070 str +6071 : +6072 str +6073 } +6074 , +6075 str +6076 : +6077 { +6078 str +6079 : +6080 str +6081 , +6082 str +6083 : +6084 str +6085 } +6086 } +6087 } +6088 , +6089 { +6090 str +6091 : +6092 str +6093 , +6094 str +6095 : +6096 { +6097 str +6098 : +6099 str +6100 , +6101 str +6102 : +6103 num +6104 , +6105 str +6106 : +6107 { +6108 str +6109 : +6110 num +6111 , +6112 str +6113 : +6114 num +6115 } +6116 , +6117 str +6118 : +6119 str +6120 , +6121 str +6122 : +6123 num +6124 , +6125 str +6126 : +6127 { +6128 str +6129 : +6130 num +6131 , +6132 str +6133 : +6134 str +6135 , +6136 str +6137 : +6138 str +6139 , +6140 str +6141 : +6142 str +6143 , +6144 str +6145 : +6146 str +6147 , +6148 str +6149 : +6150 str +6151 } +6152 , +6153 str +6154 : +6155 { +6156 str +6157 : +6158 str +6159 , +6160 str +6161 : +6162 str +6163 } +6164 } +6165 } +6166 , +6167 { +6168 str +6169 : +6170 str +6171 , +6172 str +6173 : +6174 { +6175 str +6176 : +6177 str +6178 , +6179 str +6180 : +6181 num +6182 , +6183 str +6184 : +6185 { +6186 str +6187 : +6188 num +6189 , +6190 str +6191 : +6192 num +6193 } +6194 , +6195 str +6196 : +6197 str +6198 , +6199 str +6200 : +6201 num +6202 , +6203 str +6204 : +6205 { +6206 str +6207 : +6208 num +6209 , +6210 str +6211 : +6212 str +6213 , +6214 str +6215 : +6216 str +6217 , +6218 str +6219 : +6220 str +6221 , +6222 str +6223 : +6224 str +6225 , +6226 str +6227 : +6228 str +6229 } +6230 , +6231 str +6232 : +6233 { +6234 str +6235 : +6236 str +6237 , +6238 str +6239 : +6240 str +6241 } +6242 } +6243 } +6244 , +6245 { +6246 str +6247 : +6248 str +6249 , +6250 str +6251 : +6252 { +6253 str +6254 : +6255 str +6256 , +6257 str +6258 : +6259 num +6260 , +6261 str +6262 : +6263 { +6264 str +6265 : +6266 num +6267 , +6268 str +6269 : +6270 num +6271 } +6272 , +6273 str +6274 : +6275 str +6276 , +6277 str +6278 : +6279 num +6280 , +6281 str +6282 : +6283 { +6284 str +6285 : +6286 num +6287 , +6288 str +6289 : +6290 str +6291 , +6292 str +6293 : +6294 str +6295 , +6296 str +6297 : +6298 str +6299 , +6300 str +6301 : +6302 str +6303 , +6304 str +6305 : +6306 str +6307 } +6308 , +6309 str +6310 : +6311 { +6312 str +6313 : +6314 str +6315 , +6316 str +6317 : +6318 str +6319 } +6320 } +6321 } +6322 , +6323 { +6324 str +6325 : +6326 str +6327 , +6328 str +6329 : +6330 { +6331 str +6332 : +6333 str +6334 , +6335 str +6336 : +6337 num +6338 , +6339 str +6340 : +6341 { +6342 str +6343 : +6344 num +6345 , +6346 str +6347 : +6348 num +6349 } +6350 , +6351 str +6352 : +6353 str +6354 , +6355 str +6356 : +6357 num +6358 , +6359 str +6360 : +6361 { +6362 str +6363 : +6364 num +6365 , +6366 str +6367 : +6368 str +6369 , +6370 str +6371 : +6372 str +6373 , +6374 str +6375 : +6376 str +6377 , +6378 str +6379 : +6380 str +6381 , +6382 str +6383 : +6384 str +6385 } +6386 , +6387 str +6388 : +6389 { +6390 str +6391 : +6392 str +6393 , +6394 str +6395 : +6396 str +6397 } +6398 } +6399 } +6400 , +6401 { +6402 str +6403 : +6404 str +6405 , +6406 str +6407 : +6408 { +6409 str +6410 : +6411 str +6412 , +6413 str +6414 : +6415 num +6416 , +6417 str +6418 : +6419 { +6420 str +6421 : +6422 num +6423 , +6424 str +6425 : +6426 num +6427 } +6428 , +6429 str +6430 : +6431 str +6432 , +6433 str +6434 : +6435 num +6436 , +6437 str +6438 : +6439 { +6440 str +6441 : +6442 num +6443 , +6444 str +6445 : +6446 str +6447 , +6448 str +6449 : +6450 str +6451 , +6452 str +6453 : +6454 str +6455 , +6456 str +6457 : +6458 str +6459 , +6460 str +6461 : +6462 str +6463 } +6464 , +6465 str +6466 : +6467 { +6468 str +6469 : +6470 str +6471 , +6472 str +6473 : +6474 str +6475 } +6476 } +6477 } +6478 , +6479 { +6480 str +6481 : +6482 str +6483 , +6484 str +6485 : +6486 { +6487 str +6488 : +6489 str +6490 , +6491 str +6492 : +6493 num +6494 , +6495 str +6496 : +6497 { +6498 str +6499 : +6500 num +6501 , +6502 str +6503 : +6504 num +6505 } +6506 , +6507 str +6508 : +6509 str +6510 , +6511 str +6512 : +6513 num +6514 , +6515 str +6516 : +6517 { +6518 str +6519 : +6520 num +6521 , +6522 str +6523 : +6524 str +6525 , +6526 str +6527 : +6528 str +6529 , +6530 str +6531 : +6532 str +6533 , +6534 str +6535 : +6536 str +6537 , +6538 str +6539 : +6540 str +6541 } +6542 , +6543 str +6544 : +6545 { +6546 str +6547 : +6548 str +6549 , +6550 str +6551 : +6552 str +6553 } +6554 } +6555 } +6556 , +6557 { +6558 str +6559 : +6560 str +6561 , +6562 str +6563 : +6564 { +6565 str +6566 : +6567 str +6568 , +6569 str +6570 : +6571 num +6572 , +6573 str +6574 : +6575 { +6576 str +6577 : +6578 num +6579 , +6580 str +6581 : +6582 num +6583 } +6584 , +6585 str +6586 : +6587 str +6588 , +6589 str +6590 : +6591 num +6592 , +6593 str +6594 : +6595 { +6596 str +6597 : +6598 num +6599 , +6600 str +6601 : +6602 str +6603 , +6604 str +6605 : +6606 str +6607 , +6608 str +6609 : +6610 str +6611 , +6612 str +6613 : +6614 str +6615 , +6616 str +6617 : +6618 str +6619 } +6620 , +6621 str +6622 : +6623 { +6624 str +6625 : +6626 str +6627 , +6628 str +6629 : +6630 str +6631 } +6632 } +6633 } +6634 , +6635 { +6636 str +6637 : +6638 str +6639 , +6640 str +6641 : +6642 { +6643 str +6644 : +6645 str +6646 , +6647 str +6648 : +6649 num +6650 , +6651 str +6652 : +6653 { +6654 str +6655 : +6656 num +6657 , +6658 str +6659 : +6660 num +6661 } +6662 , +6663 str +6664 : +6665 str +6666 , +6667 str +6668 : +6669 num +6670 , +6671 str +6672 : +6673 { +6674 str +6675 : +6676 num +6677 , +6678 str +6679 : +6680 str +6681 , +6682 str +6683 : +6684 str +6685 , +6686 str +6687 : +6688 str +6689 , +6690 str +6691 : +6692 str +6693 , +6694 str +6695 : +6696 str +6697 } +6698 , +6699 str +6700 : +6701 { +6702 str +6703 : +6704 str +6705 , +6706 str +6707 : +6708 str +6709 } +6710 } +6711 } +6712 , +6713 { +6714 str +6715 : +6716 str +6717 , +6718 str +6719 : +6720 { +6721 str +6722 : +6723 str +6724 , +6725 str +6726 : +6727 num +6728 , +6729 str +6730 : +6731 { +6732 str +6733 : +6734 num +6735 , +6736 str +6737 : +6738 num +6739 } +6740 , +6741 str +6742 : +6743 str +6744 , +6745 str +6746 : +6747 num +6748 , +6749 str +6750 : +6751 { +6752 str +6753 : +6754 num +6755 , +6756 str +6757 : +6758 str +6759 , +6760 str +6761 : +6762 str +6763 , +6764 str +6765 : +6766 str +6767 , +6768 str +6769 : +6770 str +6771 , +6772 str +6773 : +6774 str +6775 } +6776 , +6777 str +6778 : +6779 { +6780 str +6781 : +6782 str +6783 , +6784 str +6785 : +6786 str +6787 } +6788 } +6789 } +6790 , +6791 { +6792 str +6793 : +6794 str +6795 , +6796 str +6797 : +6798 { +6799 str +6800 : +6801 str +6802 , +6803 str +6804 : +6805 num +6806 , +6807 str +6808 : +6809 { +6810 str +6811 : +6812 num +6813 , +6814 str +6815 : +6816 num +6817 } +6818 , +6819 str +6820 : +6821 str +6822 , +6823 str +6824 : +6825 num +6826 , +6827 str +6828 : +6829 { +6830 str +6831 : +6832 num +6833 , +6834 str +6835 : +6836 str +6837 , +6838 str +6839 : +6840 str +6841 , +6842 str +6843 : +6844 str +6845 , +6846 str +6847 : +6848 str +6849 , +6850 str +6851 : +6852 str +6853 } +6854 , +6855 str +6856 : +6857 { +6858 str +6859 : +6860 str +6861 , +6862 str +6863 : +6864 str +6865 } +6866 } +6867 } +6868 , +6869 { +6870 str +6871 : +6872 str +6873 , +6874 str +6875 : +6876 { +6877 str +6878 : +6879 str +6880 , +6881 str +6882 : +6883 num +6884 , +6885 str +6886 : +6887 { +6888 str +6889 : +6890 num +6891 , +6892 str +6893 : +6894 num +6895 } +6896 , +6897 str +6898 : +6899 str +6900 , +6901 str +6902 : +6903 num +6904 , +6905 str +6906 : +6907 { +6908 str +6909 : +6910 num +6911 , +6912 str +6913 : +6914 str +6915 , +6916 str +6917 : +6918 str +6919 , +6920 str +6921 : +6922 str +6923 , +6924 str +6925 : +6926 str +6927 , +6928 str +6929 : +6930 str +6931 } +6932 , +6933 str +6934 : +6935 { +6936 str +6937 : +6938 str +6939 , +6940 str +6941 : +6942 str +6943 } +6944 } +6945 } +6946 , +6947 { +6948 str +6949 : +6950 str +6951 , +6952 str +6953 : +6954 { +6955 str +6956 : +6957 str +6958 , +6959 str +6960 : +6961 num +6962 , +6963 str +6964 : +6965 { +6966 str +6967 : +6968 num +6969 , +6970 str +6971 : +6972 num +6973 } +6974 , +6975 str +6976 : +6977 str +6978 , +6979 str +6980 : +6981 num +6982 , +6983 str +6984 : +6985 { +6986 str +6987 : +6988 num +6989 , +6990 str +6991 : +6992 str +6993 , +6994 str +6995 : +6996 str +6997 , +6998 str +6999 : +7000 str +7001 , +7002 str +7003 : +7004 str +7005 , +7006 str +7007 : +7008 str +7009 } +7010 , +7011 str +7012 : +7013 { +7014 str +7015 : +7016 str +7017 , +7018 str +7019 : +7020 str +7021 } +7022 } +7023 } +7024 , +7025 { +7026 str +7027 : +7028 str +7029 , +7030 str +7031 : +7032 { +7033 str +7034 : +7035 str +7036 , +7037 str +7038 : +7039 num +7040 , +7041 str +7042 : +7043 { +7044 str +7045 : +7046 num +7047 , +7048 str +7049 : +7050 num +7051 } +7052 , +7053 str +7054 : +7055 str +7056 , +7057 str +7058 : +7059 num +7060 , +7061 str +7062 : +7063 { +7064 str +7065 : +7066 num +7067 , +7068 str +7069 : +7070 str +7071 , +7072 str +7073 : +7074 str +7075 , +7076 str +7077 : +7078 str +7079 , +7080 str +7081 : +7082 str +7083 , +7084 str +7085 : +7086 str +7087 } +7088 , +7089 str +7090 : +7091 { +7092 str +7093 : +7094 str +7095 , +7096 str +7097 : +7098 str +7099 } +7100 } +7101 } +7102 , +7103 { +7104 str +7105 : +7106 str +7107 , +7108 str +7109 : +7110 { +7111 str +7112 : +7113 str +7114 , +7115 str +7116 : +7117 num +7118 , +7119 str +7120 : +7121 { +7122 str +7123 : +7124 num +7125 , +7126 str +7127 : +7128 num +7129 } +7130 , +7131 str +7132 : +7133 str +7134 , +7135 str +7136 : +7137 num +7138 , +7139 str +7140 : +7141 { +7142 str +7143 : +7144 num +7145 , +7146 str +7147 : +7148 str +7149 , +7150 str +7151 : +7152 str +7153 , +7154 str +7155 : +7156 str +7157 , +7158 str +7159 : +7160 str +7161 , +7162 str +7163 : +7164 str +7165 } +7166 , +7167 str +7168 : +7169 { +7170 str +7171 : +7172 str +7173 , +7174 str +7175 : +7176 str +7177 } +7178 } +7179 } +7180 , +7181 { +7182 str +7183 : +7184 str +7185 , +7186 str +7187 : +7188 { +7189 str +7190 : +7191 str +7192 , +7193 str +7194 : +7195 num +7196 , +7197 str +7198 : +7199 { +7200 str +7201 : +7202 num +7203 , +7204 str +7205 : +7206 num +7207 } +7208 , +7209 str +7210 : +7211 str +7212 , +7213 str +7214 : +7215 num +7216 , +7217 str +7218 : +7219 { +7220 str +7221 : +7222 num +7223 , +7224 str +7225 : +7226 str +7227 , +7228 str +7229 : +7230 str +7231 , +7232 str +7233 : +7234 str +7235 , +7236 str +7237 : +7238 str +7239 , +7240 str +7241 : +7242 str +7243 } +7244 , +7245 str +7246 : +7247 { +7248 str +7249 : +7250 str +7251 , +7252 str +7253 : +7254 str +7255 } +7256 } +7257 } +7258 , +7259 { +7260 str +7261 : +7262 str +7263 , +7264 str +7265 : +7266 { +7267 str +7268 : +7269 str +7270 , +7271 str +7272 : +7273 num +7274 , +7275 str +7276 : +7277 { +7278 str +7279 : +7280 num +7281 , +7282 str +7283 : +7284 num +7285 } +7286 , +7287 str +7288 : +7289 str +7290 , +7291 str +7292 : +7293 num +7294 , +7295 str +7296 : +7297 { +7298 str +7299 : +7300 num +7301 , +7302 str +7303 : +7304 str +7305 , +7306 str +7307 : +7308 str +7309 , +7310 str +7311 : +7312 str +7313 , +7314 str +7315 : +7316 str +7317 , +7318 str +7319 : +7320 str +7321 } +7322 , +7323 str +7324 : +7325 { +7326 str +7327 : +7328 str +7329 , +7330 str +7331 : +7332 str +7333 } +7334 } +7335 } +7336 , +7337 { +7338 str +7339 : +7340 str +7341 , +7342 str +7343 : +7344 { +7345 str +7346 : +7347 str +7348 , +7349 str +7350 : +7351 num +7352 , +7353 str +7354 : +7355 { +7356 str +7357 : +7358 num +7359 , +7360 str +7361 : +7362 num +7363 } +7364 , +7365 str +7366 : +7367 str +7368 , +7369 str +7370 : +7371 num +7372 , +7373 str +7374 : +7375 { +7376 str +7377 : +7378 num +7379 , +7380 str +7381 : +7382 str +7383 , +7384 str +7385 : +7386 str +7387 , +7388 str +7389 : +7390 str +7391 , +7392 str +7393 : +7394 str +7395 , +7396 str +7397 : +7398 str +7399 } +7400 , +7401 str +7402 : +7403 { +7404 str +7405 : +7406 str +7407 , +7408 str +7409 : +7410 str +7411 } +7412 } +7413 } +7414 , +7415 { +7416 str +7417 : +7418 str +7419 , +7420 str +7421 : +7422 { +7423 str +7424 : +7425 str +7426 , +7427 str +7428 : +7429 num +7430 , +7431 str +7432 : +7433 { +7434 str +7435 : +7436 num +7437 , +7438 str +7439 : +7440 num +7441 } +7442 , +7443 str +7444 : +7445 str +7446 , +7447 str +7448 : +7449 num +7450 , +7451 str +7452 : +7453 { +7454 str +7455 : +7456 num +7457 , +7458 str +7459 : +7460 str +7461 , +7462 str +7463 : +7464 str +7465 , +7466 str +7467 : +7468 str +7469 , +7470 str +7471 : +7472 str +7473 , +7474 str +7475 : +7476 str +7477 } +7478 , +7479 str +7480 : +7481 { +7482 str +7483 : +7484 str +7485 , +7486 str +7487 : +7488 str +7489 } +7490 } +7491 } +7492 , +7493 { +7494 str +7495 : +7496 str +7497 , +7498 str +7499 : +7500 { +7501 str +7502 : +7503 str +7504 , +7505 str +7506 : +7507 num +7508 , +7509 str +7510 : +7511 { +7512 str +7513 : +7514 num +7515 , +7516 str +7517 : +7518 num +7519 } +7520 , +7521 str +7522 : +7523 str +7524 , +7525 str +7526 : +7527 num +7528 , +7529 str +7530 : +7531 { +7532 str +7533 : +7534 num +7535 , +7536 str +7537 : +7538 str +7539 , +7540 str +7541 : +7542 str +7543 , +7544 str +7545 : +7546 str +7547 , +7548 str +7549 : +7550 str +7551 , +7552 str +7553 : +7554 str +7555 } +7556 , +7557 str +7558 : +7559 { +7560 str +7561 : +7562 str +7563 , +7564 str +7565 : +7566 str +7567 } +7568 } +7569 } +7570 , +7571 { +7572 str +7573 : +7574 str +7575 , +7576 str +7577 : +7578 { +7579 str +7580 : +7581 str +7582 , +7583 str +7584 : +7585 num +7586 , +7587 str +7588 : +7589 { +7590 str +7591 : +7592 num +7593 , +7594 str +7595 : +7596 num +7597 } +7598 , +7599 str +7600 : +7601 str +7602 , +7603 str +7604 : +7605 num +7606 , +7607 str +7608 : +7609 { +7610 str +7611 : +7612 num +7613 , +7614 str +7615 : +7616 str +7617 , +7618 str +7619 : +7620 str +7621 , +7622 str +7623 : +7624 str +7625 , +7626 str +7627 : +7628 str +7629 , +7630 str +7631 : +7632 str +7633 } +7634 , +7635 str +7636 : +7637 { +7638 str +7639 : +7640 str +7641 , +7642 str +7643 : +7644 str +7645 } +7646 } +7647 } +7648 , +7649 { +7650 str +7651 : +7652 str +7653 , +7654 str +7655 : +7656 { +7657 str +7658 : +7659 str +7660 , +7661 str +7662 : +7663 num +7664 , +7665 str +7666 : +7667 { +7668 str +7669 : +7670 num +7671 , +7672 str +7673 : +7674 num +7675 } +7676 , +7677 str +7678 : +7679 str +7680 , +7681 str +7682 : +7683 num +7684 , +7685 str +7686 : +7687 { +7688 str +7689 : +7690 num +7691 , +7692 str +7693 : +7694 str +7695 , +7696 str +7697 : +7698 str +7699 , +7700 str +7701 : +7702 str +7703 , +7704 str +7705 : +7706 str +7707 , +7708 str +7709 : +7710 str +7711 } +7712 , +7713 str +7714 : +7715 { +7716 str +7717 : +7718 str +7719 , +7720 str +7721 : +7722 str +7723 } +7724 } +7725 } +7726 , +7727 { +7728 str +7729 : +7730 str +7731 , +7732 str +7733 : +7734 { +7735 str +7736 : +7737 str +7738 , +7739 str +7740 : +7741 num +7742 , +7743 str +7744 : +7745 { +7746 str +7747 : +7748 num +7749 , +7750 str +7751 : +7752 num +7753 } +7754 , +7755 str +7756 : +7757 str +7758 , +7759 str +7760 : +7761 num +7762 , +7763 str +7764 : +7765 { +7766 str +7767 : +7768 num +7769 , +7770 str +7771 : +7772 str +7773 , +7774 str +7775 : +7776 str +7777 , +7778 str +7779 : +7780 str +7781 , +7782 str +7783 : +7784 str +7785 , +7786 str +7787 : +7788 str +7789 } +7790 , +7791 str +7792 : +7793 { +7794 str +7795 : +7796 str +7797 , +7798 str +7799 : +7800 str +7801 } +7802 } +7803 } +7804 ] +7805 , +7806 str +7807 : +7808 { +7809 str +7810 : +7811 str +7812 , +7813 str +7814 : +7815 num +7816 , +7817 str +7818 : +7819 num +7820 } +7821 } \ No newline at end of file diff --git a/tests/cykjson_small_token.csv b/tests/cykjson_small_token.csv new file mode 100644 index 0000000..9d48b3b --- /dev/null +++ b/tests/cykjson_small_token.csv @@ -0,0 +1,801 @@ +1 { +2 str +3 : +4 [ +5 { +6 str +7 : +8 str +9 , +10 str +11 : +12 { +13 str +14 : +15 str +16 , +17 str +18 : +19 num +20 , +21 str +22 : +23 { +24 str +25 : +26 num +27 , +28 str +29 : +30 num +31 } +32 , +33 str +34 : +35 str +36 , +37 str +38 : +39 num +40 , +41 str +42 : +43 { +44 str +45 : +46 num +47 , +48 str +49 : +50 str +51 , +52 str +53 : +54 str +55 , +56 str +57 : +58 str +59 , +60 str +61 : +62 str +63 , +64 str +65 : +66 str +67 } +68 , +69 str +70 : +71 { +72 str +73 : +74 str +75 , +76 str +77 : +78 str +79 } +80 } +81 } +82 , +83 { +84 str +85 : +86 str +87 , +88 str +89 : +90 { +91 str +92 : +93 str +94 , +95 str +96 : +97 num +98 , +99 str +100 : +101 { +102 str +103 : +104 num +105 , +106 str +107 : +108 num +109 } +110 , +111 str +112 : +113 str +114 , +115 str +116 : +117 num +118 , +119 str +120 : +121 { +122 str +123 : +124 num +125 , +126 str +127 : +128 str +129 , +130 str +131 : +132 str +133 , +134 str +135 : +136 str +137 , +138 str +139 : +140 str +141 , +142 str +143 : +144 str +145 } +146 , +147 str +148 : +149 { +150 str +151 : +152 str +153 , +154 str +155 : +156 str +157 } +158 } +159 } +160 , +161 { +162 str +163 : +164 str +165 , +166 str +167 : +168 { +169 str +170 : +171 str +172 , +173 str +174 : +175 num +176 , +177 str +178 : +179 { +180 str +181 : +182 num +183 , +184 str +185 : +186 num +187 } +188 , +189 str +190 : +191 str +192 , +193 str +194 : +195 num +196 , +197 str +198 : +199 { +200 str +201 : +202 num +203 , +204 str +205 : +206 str +207 , +208 str +209 : +210 str +211 , +212 str +213 : +214 str +215 , +216 str +217 : +218 str +219 , +220 str +221 : +222 str +223 } +224 , +225 str +226 : +227 { +228 str +229 : +230 str +231 , +232 str +233 : +234 str +235 } +236 } +237 } +238 , +239 { +240 str +241 : +242 str +243 , +244 str +245 : +246 { +247 str +248 : +249 str +250 , +251 str +252 : +253 num +254 , +255 str +256 : +257 { +258 str +259 : +260 num +261 , +262 str +263 : +264 num +265 } +266 , +267 str +268 : +269 str +270 , +271 str +272 : +273 num +274 , +275 str +276 : +277 { +278 str +279 : +280 num +281 , +282 str +283 : +284 str +285 , +286 str +287 : +288 str +289 , +290 str +291 : +292 str +293 , +294 str +295 : +296 str +297 , +298 str +299 : +300 str +301 } +302 , +303 str +304 : +305 { +306 str +307 : +308 str +309 , +310 str +311 : +312 str +313 } +314 } +315 } +316 , +317 { +318 str +319 : +320 str +321 , +322 str +323 : +324 { +325 str +326 : +327 str +328 , +329 str +330 : +331 num +332 , +333 str +334 : +335 { +336 str +337 : +338 num +339 , +340 str +341 : +342 num +343 } +344 , +345 str +346 : +347 str +348 , +349 str +350 : +351 num +352 , +353 str +354 : +355 { +356 str +357 : +358 num +359 , +360 str +361 : +362 str +363 , +364 str +365 : +366 str +367 , +368 str +369 : +370 str +371 , +372 str +373 : +374 str +375 , +376 str +377 : +378 str +379 } +380 , +381 str +382 : +383 { +384 str +385 : +386 str +387 , +388 str +389 : +390 str +391 } +392 } +393 } +394 , +395 { +396 str +397 : +398 str +399 , +400 str +401 : +402 { +403 str +404 : +405 str +406 , +407 str +408 : +409 num +410 , +411 str +412 : +413 { +414 str +415 : +416 num +417 , +418 str +419 : +420 num +421 } +422 , +423 str +424 : +425 str +426 , +427 str +428 : +429 num +430 , +431 str +432 : +433 { +434 str +435 : +436 num +437 , +438 str +439 : +440 str +441 , +442 str +443 : +444 str +445 , +446 str +447 : +448 str +449 , +450 str +451 : +452 str +453 , +454 str +455 : +456 str +457 } +458 , +459 str +460 : +461 { +462 str +463 : +464 str +465 , +466 str +467 : +468 str +469 } +470 } +471 } +472 , +473 { +474 str +475 : +476 str +477 , +478 str +479 : +480 { +481 str +482 : +483 str +484 , +485 str +486 : +487 num +488 , +489 str +490 : +491 { +492 str +493 : +494 num +495 , +496 str +497 : +498 num +499 } +500 , +501 str +502 : +503 str +504 , +505 str +506 : +507 num +508 , +509 str +510 : +511 { +512 str +513 : +514 num +515 , +516 str +517 : +518 str +519 , +520 str +521 : +522 str +523 , +524 str +525 : +526 str +527 , +528 str +529 : +530 str +531 , +532 str +533 : +534 str +535 } +536 , +537 str +538 : +539 { +540 str +541 : +542 str +543 , +544 str +545 : +546 str +547 } +548 } +549 } +550 , +551 { +552 str +553 : +554 str +555 , +556 str +557 : +558 { +559 str +560 : +561 str +562 , +563 str +564 : +565 num +566 , +567 str +568 : +569 { +570 str +571 : +572 num +573 , +574 str +575 : +576 num +577 } +578 , +579 str +580 : +581 str +582 , +583 str +584 : +585 num +586 , +587 str +588 : +589 { +590 str +591 : +592 num +593 , +594 str +595 : +596 str +597 , +598 str +599 : +600 str +601 , +602 str +603 : +604 str +605 , +606 str +607 : +608 str +609 , +610 str +611 : +612 str +613 } +614 , +615 str +616 : +617 { +618 str +619 : +620 str +621 , +622 str +623 : +624 str +625 } +626 } +627 } +628 , +629 { +630 str +631 : +632 str +633 , +634 str +635 : +636 { +637 str +638 : +639 str +640 , +641 str +642 : +643 num +644 , +645 str +646 : +647 { +648 str +649 : +650 num +651 , +652 str +653 : +654 num +655 } +656 , +657 str +658 : +659 str +660 , +661 str +662 : +663 num +664 , +665 str +666 : +667 { +668 str +669 : +670 num +671 , +672 str +673 : +674 str +675 , +676 str +677 : +678 str +679 , +680 str +681 : +682 str +683 , +684 str +685 : +686 str +687 , +688 str +689 : +690 str +691 } +692 , +693 str +694 : +695 { +696 str +697 : +698 str +699 , +700 str +701 : +702 str +703 } +704 } +705 } +706 , +707 { +708 str +709 : +710 str +711 , +712 str +713 : +714 { +715 str +716 : +717 str +718 , +719 str +720 : +721 num +722 , +723 str +724 : +725 { +726 str +727 : +728 num +729 , +730 str +731 : +732 num +733 } +734 , +735 str +736 : +737 str +738 , +739 str +740 : +741 num +742 , +743 str +744 : +745 { +746 str +747 : +748 num +749 , +750 str +751 : +752 str +753 , +754 str +755 : +756 str +757 , +758 str +759 : +760 str +761 , +762 str +763 : +764 str +765 , +766 str +767 : +768 str +769 } +770 , +771 str +772 : +773 { +774 str +775 : +776 str +777 , +778 str +779 : +780 str +781 } +782 } +783 } +784 ] +785 , +786 str +787 : +788 { +789 str +790 : +791 str +792 , +793 str +794 : +795 num +796 , +797 str +798 : +799 num +800 } +801 } \ No newline at end of file diff --git a/tests/datatypes.egg b/tests/datatypes.egg new file mode 100644 index 0000000..9f5cfa8 --- /dev/null +++ b/tests/datatypes.egg @@ -0,0 +1,11 @@ +(datatype* + (Math + (Add Math Math) + (Sum MathVec) + (B Bool)) + (sort MathVec (Vec Math)) + (Bool + (True) + (False))) + +(let expr (Add (Sum (vec-of (B (True)) (B (False)))) (B (True)))) diff --git a/tests/delete.egg b/tests/delete.egg new file mode 100644 index 0000000..15fd4c8 --- /dev/null +++ b/tests/delete.egg @@ -0,0 +1,6 @@ +(function foo (i64) i64) +(set (foo 1) 7) +(check (= (foo 1) 7)) +(delete (foo 1)) +(rule ((= x (foo 1))) ((panic "foo 1 was there!"))) +(run 1) \ No newline at end of file diff --git a/tests/eggcc-extraction.egg b/tests/eggcc-extraction.egg new file mode 100644 index 0000000..2edb8c4 --- /dev/null +++ b/tests/eggcc-extraction.egg @@ -0,0 +1,1711 @@ + +(datatype Literal) +(datatype Expr) +(datatype Operand) +(datatype Body) + +(sort VecOperandBase (Vec Operand)) +(datatype VecOperand (VO VecOperandBase)) + +(sort VecVecOperandBase (Vec VecOperand)) +(datatype VecVecOperand (VVO VecVecOperandBase)) + +;; Type +(datatype Type + (IntT) + (BoolT) + (FloatT) + (CharT) + (PointerT Type)) +(datatype EffectType + (Bril Type) + (PrintState)) +(sort FuncSigs (Vec EffectType)) +(datatype OptionType + (SomeType Type) + (NoneType)) +;; Literal +(function Num (i64) Literal) +(function Float (f64) Literal) +(function Char (String) Literal) +(function Bool (bool) Literal) + +;; Expr +(datatype ConstOps (const)) +(function Const (Type ConstOps Literal) Expr) +;; Call may return multiple values but at most one of them +;; is a value type, which is stored in OptionType. +;; The last fields denotes how many return values it have +;; Finally, we assume if call ever returns a value, +;; it has to be the first one. +(function Call (OptionType String VecOperand i64) Expr :cost 1000) ; TODO: fix cost model +(function badd (Type Operand Operand) Expr) +(function bsub (Type Operand Operand) Expr) +(function bmul (Type Operand Operand) Expr) +(function bfmul (Type Operand Operand) Expr) +(function bdiv (Type Operand Operand) Expr) +(function beq (Type Operand Operand) Expr) +(function blt (Type Operand Operand) Expr) +(function bgt (Type Operand Operand) Expr) +(function ble (Type Operand Operand) Expr) +(function bge (Type Operand Operand) Expr) +(function bnot (Type Operand Operand) Expr) +(function band (Type Operand Operand) Expr) +(function bor (Type Operand Operand) Expr) +(function PRINT (Operand Operand) Expr) + +;; Operand +(function Arg (i64) Operand) +(function Node (Body) Operand) +(function Project (i64 Body) Operand) + +;; Body +(function PureOp (Expr) Body) +;; branching +;; predicate (outside switch), inputs (outside switch), +;; and for each branch a vector of outputs +(function Gamma (Operand VecOperand VecVecOperand) Body) +;; loops +;; predicate (inside loop), inputs (outside loop), outputs (inside loop) +(function Theta (Operand VecOperand VecOperand) Body) +;; A body can also just be a VecOperand for convenience +;; This has no corresponding node in rust, it can be +;; removed during translation +(function OperandGroup (VecOperand) Body) + +(datatype Function + ;; name input types output types body + (Func String FuncSigs FuncSigs VecOperand)) + + +;; procedure f(n): +;; i = 0 +;; ans = 0 +;; do: +;; ans += i*5; +;; i += 1 +;; while(i < n); +;; return ansm + +;; ;; inputs: [n] +; (Project 0 +; (Theta +; ; i n +; (lt (Arg 1) (Arg 2)) ;; pred +; (vec-of ;; inputs +; (Node (PureOp (Const 0))) ;; accumulator +; (Node (PureOp (Const 0))) ;; loop var +; (Arg 0) ;; n +; ) +; (vec-of ;; outputs +; (Node (PureOp (add (Arg 0) ;; ans +; (Node (PureOp (mul +; (Arg 1) ;; i +; (Node (PureOp (Const 5))))))))) ;; ans = i*5 +; (Node (PureOp (add (Arg 1) (Node (PureOp (Const 1)))))) ;; i += 1 +; (Arg 2) ;; n +; )) +; ) + + + +(ruleset fast-analyses) + + (function VecOperand-get (VecOperand i64) Operand) + (rule ((VO x) (> (vec-length x) 0)) + ((union (VecOperand-get (VO x) 0) (vec-get x 0))) + :ruleset fast-analyses) + (rule ((VecOperand-get (VO x) j) + (= i (+ j 1)) (< i (vec-length x))) + ((union (VecOperand-get (VO x) i) (vec-get x i))) + :ruleset fast-analyses) + + (function VecOperand-length (VecOperand) i64) + (rule ((VO x)) + ((set (VecOperand-length (VO x)) (vec-length x))) + :ruleset fast-analyses) + + + (function VecVecOperand-get (VecVecOperand i64) VecOperand) + (rule ((VVO x) (> (vec-length x) 0)) + ((union (VecVecOperand-get (VVO x) 0) (vec-get x 0))) + :ruleset fast-analyses) + (rule ((VecVecOperand-get (VVO x) j) + (= i (+ j 1)) (< i (vec-length x))) + ((union (VecVecOperand-get (VVO x) i) (vec-get x i))) + :ruleset fast-analyses) + + (function VecVecOperand-length (VecVecOperand) i64) + (rule ((VVO x)) + ((set (VecVecOperand-length (VVO x)) (vec-length x))) + :ruleset fast-analyses) + + + (relation Expr-is-pure (Expr)) + (relation Operand-is-pure (Operand)) + (relation Body-is-pure (Body)) + (relation VecOperand-is-pure (VecOperand)) + (function VecOperand-pure-prefix (VecOperand) i64 :merge (max old new)) + (relation VecVecOperand-is-pure (VecVecOperand)) + (function VecVecOperand-pure-prefix (VecVecOperand) i64 :merge (max old new)) + (relation Function-is-pure (Function)) + + + (rule ((= f (Const ty ops lit))) + ((Expr-is-pure f)) + :ruleset fast-analyses) + + (rule ((= f (Call ty name args n-outs)) + (Function-is-pure (Func name input-types output-types body))) + ((Expr-is-pure f)) + :ruleset fast-analyses) + + + (rule ((= f (badd type e1 e2)) + (Operand-is-pure e1) + (Operand-is-pure e2)) + ((Expr-is-pure f)) + :ruleset fast-analyses) + + + (rule ((= f (bsub type e1 e2)) + (Operand-is-pure e1) + (Operand-is-pure e2)) + ((Expr-is-pure f)) + :ruleset fast-analyses) + + + (rule ((= f (bmul type e1 e2)) + (Operand-is-pure e1) + (Operand-is-pure e2)) + ((Expr-is-pure f)) + :ruleset fast-analyses) + + + (rule ((= f (bdiv type e1 e2)) + (Operand-is-pure e1) + (Operand-is-pure e2)) + ((Expr-is-pure f)) + :ruleset fast-analyses) + + + (rule ((= f (blt type e1 e2)) + (Operand-is-pure e1) + (Operand-is-pure e2)) + ((Expr-is-pure f)) + :ruleset fast-analyses) + + + (rule ((= f (Arg x))) + ((Operand-is-pure f)) + :ruleset fast-analyses) + (rule ((= f (Node body)) + (Body-is-pure body)) + ((Operand-is-pure f)) + :ruleset fast-analyses) + (rule ((= f (Project i body)) + (Body-is-pure body)) + ((Operand-is-pure f)) + :ruleset fast-analyses) + + + (rule ((= f (PureOp e)) + (Expr-is-pure e)) + ((Body-is-pure f)) + :ruleset fast-analyses) + (rule ((= f (Gamma pred inputs outputs)) + (Operand-is-pure pred) + (VecOperand-is-pure inputs) + (VecVecOperand-is-pure outputs)) + ((Body-is-pure f)) + :ruleset fast-analyses) + (rule ((= f (Theta pred inputs outputs)) + (Operand-is-pure pred) + (VecOperand-is-pure inputs) + (VecOperand-is-pure outputs)) + ((Body-is-pure f)) + :ruleset fast-analyses) + (rule ((= f (OperandGroup vec)) + (VecOperand-is-pure vec)) + ((Body-is-pure f)) + :ruleset fast-analyses) + + + (rule ((= f (VO vec))) + ((set (VecOperand-pure-prefix f) 0)) + :ruleset fast-analyses) + (rule ((= i (VecOperand-pure-prefix f)) + (< i (VecOperand-length f)) + (Operand-is-pure (VecOperand-get f i))) + ((set (VecOperand-pure-prefix f) (+ i 1))) + :ruleset fast-analyses) + (rule ((= (VecOperand-length f) (VecOperand-pure-prefix f))) + ((VecOperand-is-pure f)) + :ruleset fast-analyses) + + + (rule ((= f (VVO vec))) + ((set (VecVecOperand-pure-prefix f) 0)) + :ruleset fast-analyses) + (rule ((= i (VecVecOperand-pure-prefix f)) + (< i (VecVecOperand-length f)) + (VecOperand-is-pure (VecVecOperand-get f i))) + ((set (VecVecOperand-pure-prefix f) (+ i 1))) + :ruleset fast-analyses) + (rule ((= (VecVecOperand-length f) (VecVecOperand-pure-prefix f))) + ((VecVecOperand-is-pure f)) + :ruleset fast-analyses) + + + (rule ((= f (Func name input-types output-types body)) + (VecOperand-is-pure body)) + ((Function-is-pure f)) + :ruleset fast-analyses) + + + (relation Body-contains-Expr (Body i64 Expr)) + (relation Body-contains-Operand (Body i64 Operand)) + (relation Body-contains-Body (Body i64 Body)) + + + (rule ((= f (PureOp e))) + ((Body-contains-Expr f 0 e)) + :ruleset fast-analyses) + ; A Gamma only contains its outputs + (rule ((= f (Gamma pred inputs outputs)) + (= outputs-i (VecVecOperand-get outputs i)) + (= x (VecOperand-get outputs-i j))) + ((Body-contains-Operand f i x)) + :ruleset fast-analyses) + ; A Theta contains its pred and outputs + (rule ((= f (Theta pred inputs outputs))) + ((Body-contains-Operand f -1 pred)) + :ruleset fast-analyses) + (rule ((= f (Theta pred inputs outputs)) + (= x (VecOperand-get outputs i))) + ((Body-contains-Operand f i x)) + :ruleset fast-analyses) + (rule ((= f (OperandGroup vec)) + (= x (VecOperand-get vec i))) + ((Body-contains-Operand f i x)) + :ruleset fast-analyses) + + + (rule ((Body-contains-Body f i (PureOp e))) + ((Body-contains-Expr f i e)) + :ruleset fast-analyses) + ; A Gamma's pred and inputs are in the outer context + (rule ((Body-contains-Body f i (Gamma pred inputs outputs))) + ((Body-contains-Operand f i pred)) + :ruleset fast-analyses) + (rule ((Body-contains-Body f i (Gamma pred inputs outputs)) + (= x (VecOperand-get inputs any))) + ((Body-contains-Operand f i x)) + :ruleset fast-analyses) + ; A Theta's inputs are in the outer context + (rule ((Body-contains-Body f i (Theta pred inputs outputs)) + (= x (VecOperand-get inputs any))) + ((Body-contains-Operand f i x)) + :ruleset fast-analyses) + (rule ((Body-contains-Body f i (OperandGroup vec)) + (= x (VecOperand-get vec any))) + ((Body-contains-Operand f i x)) + :ruleset fast-analyses) + + + (rule ((Body-contains-Expr f i (Call ty name args n-outs)) + (= x (VecOperand-get args any))) + ((Body-contains-Operand f i x)) + :ruleset fast-analyses) + (rule ((Body-contains-Expr f i (PRINT e1 e2))) + ((Body-contains-Operand f i e1) + (Body-contains-Operand f i e2)) + :ruleset fast-analyses) + + + (rule ((Body-contains-Expr f i (badd type e1 e2))) + ((Body-contains-Operand f i e1) + (Body-contains-Operand f i e2)) + :ruleset fast-analyses) + + + (rule ((Body-contains-Expr f i (bsub type e1 e2))) + ((Body-contains-Operand f i e1) + (Body-contains-Operand f i e2)) + :ruleset fast-analyses) + + + (rule ((Body-contains-Expr f i (bmul type e1 e2))) + ((Body-contains-Operand f i e1) + (Body-contains-Operand f i e2)) + :ruleset fast-analyses) + + + (rule ((Body-contains-Expr f i (bdiv type e1 e2))) + ((Body-contains-Operand f i e1) + (Body-contains-Operand f i e2)) + :ruleset fast-analyses) + + + (rule ((Body-contains-Expr f i (blt type e1 e2))) + ((Body-contains-Operand f i e1) + (Body-contains-Operand f i e2)) + :ruleset fast-analyses) + + + (rule ((Body-contains-Operand f i (Node body))) + ((Body-contains-Body f i body)) + :ruleset fast-analyses) + (rule ((Body-contains-Operand f i (Project i body))) + ((Body-contains-Body f i body)) + :ruleset fast-analyses) + +(ruleset subst) (ruleset shift) + + (relation can-subst-Expr-beneath (Body Expr Expr)) + (relation can-subst-Operand-beneath (Body Operand Operand)) + (relation can-subst-Body-beneath (Body Body Body)) + (relation can-subst-VecVecOperand-beneath (Body VecVecOperand VecVecOperand)) + (relation can-subst-VecOperand-beneath (Body VecOperand VecOperand)) + + ;; Base case 'do the substitution' rules + (rule ((can-subst-Operand-beneath above from to) + (= above (Theta from inputs outputs))) + ((union above (Theta to inputs outputs))) + :ruleset subst) + (rule ((can-subst-VecOperand-beneath above from to) + (= above (Theta pred inputs from))) + ((union above (Theta pred inputs to))) + :ruleset subst) + (rule ((can-subst-Operand-beneath above pred-from pred-to) + (can-subst-VecOperand-beneath above outputs-from outputs-to) + (= above (Theta pred-from inputs outputs-from))) + ((union above (Theta pred-from inputs outputs-to))) + :ruleset subst) + (rule ((can-subst-VecVecOperand-beneath above from to) + (= above (Gamma pred inputs from))) + ((union above (Gamma pred inputs to))) + :ruleset subst) + (rule ((can-subst-VecOperand-beneath above from to) + (= above (OperandGroup from))) + ((union above (OperandGroup to))) + :ruleset subst) + + ;; Learn can-subst-Operand-beneath + (rule ((can-subst-Body-beneath above from to) + (= new-from (Node from))) + ((can-subst-Operand-beneath above new-from (Node to))) + :ruleset subst) + (rule ((can-subst-Body-beneath above from to) + (= new-from (Project i from))) + ((can-subst-Operand-beneath above new-from (Project i to))) + :ruleset subst) + + ;; Learn can-subst-body-beneath + (rule ((can-subst-Expr-beneath above from to) + (= new-from (PureOp from))) + ((can-subst-Body-beneath above new-from (PureOp to))) + :ruleset subst) + ;; Propagates up same context (Gamma: pred & inputs, Theta: inputs) + ;; rtjoa: Is it sound to propagate up outputs if we renumber args? + (rule ((can-subst-Operand-beneath above from to) + (= new-from (Gamma from inputs outputs))) + ((can-subst-Body-beneath above new-from (Gamma to inputs outputs))) + :ruleset subst) + (rule ((can-subst-VecOperand-beneath above from to) + (= new-from (Gamma pred from outputs))) + ((can-subst-Body-beneath above new-from (Gamma pred to outputs))) + :ruleset subst) + (rule ((can-subst-VecOperand-beneath above from to) + (= new-from (Theta pred from outputs))) + ((can-subst-Body-beneath above new-from (Theta pred to outputs))) + :ruleset subst) + (rule ((can-subst-VecOperand-beneath above from to) + (= new-from (OperandGroup from))) + ((can-subst-Body-beneath above new-from (OperandGroup to))) + :ruleset subst) + + + (rule ((can-subst-VecOperand-beneath above from to) + (= new-from (Call ty f from n-outs))) + ((can-subst-Expr-beneath above new-from (Call ty f to n-outs))) + :ruleset subst) + + (rule ((can-subst-Operand-beneath above from to) + (= new-from (badd type from e2))) + ((can-subst-Expr-beneath above new-from (badd type to e2))) + :ruleset subst) + (rule ((can-subst-Operand-beneath above from to) + (= new-from (badd type e1 from))) + ((can-subst-Expr-beneath above new-from (badd type e1 to))) + :ruleset subst) + + + (rule ((can-subst-Operand-beneath above from to) + (= new-from (bsub type from e2))) + ((can-subst-Expr-beneath above new-from (bsub type to e2))) + :ruleset subst) + (rule ((can-subst-Operand-beneath above from to) + (= new-from (bsub type e1 from))) + ((can-subst-Expr-beneath above new-from (bsub type e1 to))) + :ruleset subst) + + + (rule ((can-subst-Operand-beneath above from to) + (= new-from (bmul type from e2))) + ((can-subst-Expr-beneath above new-from (bmul type to e2))) + :ruleset subst) + (rule ((can-subst-Operand-beneath above from to) + (= new-from (bmul type e1 from))) + ((can-subst-Expr-beneath above new-from (bmul type e1 to))) + :ruleset subst) + + + (rule ((can-subst-Operand-beneath above from to) + (= new-from (bdiv type from e2))) + ((can-subst-Expr-beneath above new-from (bdiv type to e2))) + :ruleset subst) + (rule ((can-subst-Operand-beneath above from to) + (= new-from (bdiv type e1 from))) + ((can-subst-Expr-beneath above new-from (bdiv type e1 to))) + :ruleset subst) + + + (rule ((can-subst-Operand-beneath above from to) + (= new-from (blt type from e2))) + ((can-subst-Expr-beneath above new-from (blt type to e2))) + :ruleset subst) + (rule ((can-subst-Operand-beneath above from to) + (= new-from (blt type e1 from))) + ((can-subst-Expr-beneath above new-from (blt type e1 to))) + :ruleset subst) + + + (rule ((can-subst-Operand-beneath above from to) + (= from (VecOperand-get (VO vec) i))) + ((can-subst-VecOperand-beneath + above + (VO vec) + (VO (vec-set vec i to)))) + :ruleset subst) + + (rule ((can-subst-VecOperand-beneath above from to) + (= from (VecVecOperand-get (VVO vec) i))) + ((can-subst-VecVecOperand-beneath + above + (VVO vec) + (VVO (vec-set vec i to)))) + :ruleset subst) +(function SubstExpr (Expr i64 Operand) Expr :unextractable) +(function SubstOperand (Operand i64 Operand) Operand :unextractable) +(function SubstBody (Body i64 Operand) Body :unextractable) +(function SubstVecOperand (VecOperand i64 Operand) VecOperand :unextractable) +(function SubstVecVecOperand (VecVecOperand i64 Operand) VecVecOperand :unextractable) + + (rewrite + (SubstExpr (badd ty a b) x0 x1) + (badd + ty + (SubstOperand a x0 x1) + (SubstOperand b x0 x1)) + :ruleset subst) + + + (rewrite + (SubstExpr (bsub ty a b) x0 x1) + (bsub + ty + (SubstOperand a x0 x1) + (SubstOperand b x0 x1)) + :ruleset subst) + + + (rewrite + (SubstExpr (bmul ty a b) x0 x1) + (bmul + ty + (SubstOperand a x0 x1) + (SubstOperand b x0 x1)) + :ruleset subst) + + + (rewrite + (SubstExpr (bdiv ty a b) x0 x1) + (bdiv + ty + (SubstOperand a x0 x1) + (SubstOperand b x0 x1)) + :ruleset subst) + + + (rewrite + (SubstExpr (blt ty a b) x0 x1) + (blt + ty + (SubstOperand a x0 x1) + (SubstOperand b x0 x1)) + :ruleset subst) + + + (rewrite + (SubstExpr (Const ty ops lit) x0 x1) + (Const ty ops lit) + :ruleset subst) + (rewrite + (SubstExpr (Call ty f args n-outs) x0 x1) + (Call ty f (SubstVecOperand args x0 x1) n-outs) + :ruleset subst) + (rewrite + (SubstExpr (PRINT a b) x0 x1) + (PRINT (SubstOperand a x0 x1) (SubstOperand b x0 x1)) + :ruleset subst) + + (rewrite (SubstOperand (Arg x) x v) v :ruleset subst) + (rule ((= f (SubstOperand (Arg y) x v)) (!= y x)) + ((union f (Arg y))) :ruleset subst) + + (rewrite + (SubstOperand (Node b) x0 x1) + (Node (SubstBody b x0 x1)) + :ruleset subst) + (rewrite + (SubstOperand (Project i b) x0 x1) + (Project i (SubstBody b x0 x1)) + :ruleset subst) + + (rewrite + (SubstBody (PureOp e) x0 x1) + (PureOp (SubstExpr e x0 x1)) + :ruleset subst) + ;; Don't cross regions, so so we shift into the inputs but not outputs + ;; A Gamma's pred is on the outside, so it's affected, but not a Theta's + (rewrite + (SubstBody (Gamma pred inputs outputs) x0 x1) + (Gamma + (SubstOperand pred x0 x1) + (SubstVecOperand inputs x0 x1) + outputs) + :ruleset subst) + (rewrite + (SubstBody (Theta pred inputs outputs) x0 x1) + (Theta pred (SubstVecOperand inputs x0 x1) outputs) + :ruleset subst) + + (function SubstVecOperand-helper (VecOperand i64 Operand i64) VecOperand) + (rewrite + (SubstVecOperand vec x0 x1) + (SubstVecOperand-helper vec x0 x1 0) + :ruleset subst) + (rule + ((= f (SubstVecOperand-helper (VO vec) x0 x1 i)) + (< i (vec-length vec))) + ((union + (SubstVecOperand-helper (VO vec) x0 x1 i) + (SubstVecOperand-helper + (VO (vec-set vec i (SubstOperand (vec-get vec i) x0 x1))) + x0 x1 (+ i 1)))) + :ruleset subst) + (rule + ((= f (SubstVecOperand-helper (VO vec) x0 x1 i)) + (= i (vec-length vec))) + ((union + (SubstVecOperand-helper (VO vec) x0 x1 i) + (VO vec))) + :ruleset subst) + + (function SubstVecVecOperand-helper (VecVecOperand i64 Operand i64) VecVecOperand) + (rewrite + (SubstVecVecOperand vec x0 x1) + (SubstVecVecOperand-helper vec x0 x1 0) + :ruleset subst) + (rule + ((= f (SubstVecVecOperand-helper (VVO vec) x0 x1 i)) + (< i (vec-length vec))) + ((union + (SubstVecVecOperand-helper (VVO vec) x0 x1 i) + (SubstVecVecOperand-helper + (VVO (vec-set vec i (SubstVecOperand (vec-get vec i) x0 x1))) + x0 x1 (+ i 1)))) + :ruleset subst) + (rule + ((= f (SubstVecVecOperand-helper (VVO vec) x0 x1 i)) + (= i (vec-length vec))) + ((union + (SubstVecVecOperand-helper (VVO vec) x0 x1 i) + (VVO vec))) + :ruleset subst) +(function SubstExprAll (Expr VecOperand) Expr :unextractable) +(function SubstOperandAll (Operand VecOperand) Operand :unextractable) +(function SubstBodyAll (Body VecOperand) Body :unextractable) +(function SubstVecOperandAll (VecOperand VecOperand) VecOperand :unextractable) +(function SubstVecVecOperandAll (VecVecOperand VecOperand) VecVecOperand :unextractable) + + (rewrite + (SubstExprAll (badd ty a b) x0) + (badd + ty + (SubstOperandAll a x0) + (SubstOperandAll b x0)) + :ruleset subst) + + + (rewrite + (SubstExprAll (bsub ty a b) x0) + (bsub + ty + (SubstOperandAll a x0) + (SubstOperandAll b x0)) + :ruleset subst) + + + (rewrite + (SubstExprAll (bmul ty a b) x0) + (bmul + ty + (SubstOperandAll a x0) + (SubstOperandAll b x0)) + :ruleset subst) + + + (rewrite + (SubstExprAll (bdiv ty a b) x0) + (bdiv + ty + (SubstOperandAll a x0) + (SubstOperandAll b x0)) + :ruleset subst) + + + (rewrite + (SubstExprAll (blt ty a b) x0) + (blt + ty + (SubstOperandAll a x0) + (SubstOperandAll b x0)) + :ruleset subst) + + + (rewrite + (SubstExprAll (Const ty ops lit) x0) + (Const ty ops lit) + :ruleset subst) + (rewrite + (SubstExprAll (Call ty f args n-outs) x0) + (Call ty f (SubstVecOperandAll args x0) n-outs) + :ruleset subst) + (rewrite + (SubstExprAll (PRINT a b) x0) + (PRINT (SubstOperandAll a x0) (SubstOperandAll b x0)) + :ruleset subst) + + (rule ((= f (SubstOperandAll (Arg x) (VO ops))) + (< x (vec-length ops))) + ((union f (vec-get ops x))) :ruleset subst) + + (rewrite + (SubstOperandAll (Node b) x0) + (Node (SubstBodyAll b x0)) + :ruleset subst) + (rewrite + (SubstOperandAll (Project i b) x0) + (Project i (SubstBodyAll b x0)) + :ruleset subst) + + (rewrite + (SubstBodyAll (PureOp e) x0) + (PureOp (SubstExprAll e x0)) + :ruleset subst) + ;; Don't cross regions, so so we shift into the inputs but not outputs + ;; A Gamma's pred is on the outside, so it's affected, but not a Theta's + (rewrite + (SubstBodyAll (Gamma pred inputs outputs) x0) + (Gamma + (SubstOperandAll pred x0) + (SubstVecOperandAll inputs x0) + outputs) + :ruleset subst) + (rewrite + (SubstBodyAll (Theta pred inputs outputs) x0) + (Theta pred (SubstVecOperandAll inputs x0) outputs) + :ruleset subst) + + (function SubstVecOperandAll-helper (VecOperand VecOperand i64) VecOperand) + (rewrite + (SubstVecOperandAll vec x0) + (SubstVecOperandAll-helper vec x0 0) + :ruleset subst) + (rule + ((= f (SubstVecOperandAll-helper (VO vec) x0 i)) + (< i (vec-length vec))) + ((union + (SubstVecOperandAll-helper (VO vec) x0 i) + (SubstVecOperandAll-helper + (VO (vec-set vec i (SubstOperandAll (vec-get vec i) x0))) + x0 (+ i 1)))) + :ruleset subst) + (rule + ((= f (SubstVecOperandAll-helper (VO vec) x0 i)) + (= i (vec-length vec))) + ((union + (SubstVecOperandAll-helper (VO vec) x0 i) + (VO vec))) + :ruleset subst) + + (function SubstVecVecOperandAll-helper (VecVecOperand VecOperand i64) VecVecOperand) + (rewrite + (SubstVecVecOperandAll vec x0) + (SubstVecVecOperandAll-helper vec x0 0) + :ruleset subst) + (rule + ((= f (SubstVecVecOperandAll-helper (VVO vec) x0 i)) + (< i (vec-length vec))) + ((union + (SubstVecVecOperandAll-helper (VVO vec) x0 i) + (SubstVecVecOperandAll-helper + (VVO (vec-set vec i (SubstVecOperandAll (vec-get vec i) x0))) + x0 (+ i 1)))) + :ruleset subst) + (rule + ((= f (SubstVecVecOperandAll-helper (VVO vec) x0 i)) + (= i (vec-length vec))) + ((union + (SubstVecVecOperandAll-helper (VVO vec) x0 i) + (VVO vec))) + :ruleset subst) +(function ShiftExpr (Expr i64 i64) Expr :unextractable) +(function ShiftOperand (Operand i64 i64) Operand :unextractable) +(function ShiftBody (Body i64 i64) Body :unextractable) +(function ShiftVecOperand (VecOperand i64 i64) VecOperand :unextractable) +(function ShiftVecVecOperand (VecVecOperand i64 i64) VecVecOperand :unextractable) + + (rewrite + (ShiftExpr (badd ty a b) x0 x1) + (badd + ty + (ShiftOperand a x0 x1) + (ShiftOperand b x0 x1)) + :ruleset shift) + + + (rewrite + (ShiftExpr (bsub ty a b) x0 x1) + (bsub + ty + (ShiftOperand a x0 x1) + (ShiftOperand b x0 x1)) + :ruleset shift) + + + (rewrite + (ShiftExpr (bmul ty a b) x0 x1) + (bmul + ty + (ShiftOperand a x0 x1) + (ShiftOperand b x0 x1)) + :ruleset shift) + + + (rewrite + (ShiftExpr (bdiv ty a b) x0 x1) + (bdiv + ty + (ShiftOperand a x0 x1) + (ShiftOperand b x0 x1)) + :ruleset shift) + + + (rewrite + (ShiftExpr (blt ty a b) x0 x1) + (blt + ty + (ShiftOperand a x0 x1) + (ShiftOperand b x0 x1)) + :ruleset shift) + + + (rewrite + (ShiftExpr (Const ty ops lit) x0 x1) + (Const ty ops lit) + :ruleset shift) + (rewrite + (ShiftExpr (Call ty f args n-outs) x0 x1) + (Call ty f (ShiftVecOperand args x0 x1) n-outs) + :ruleset shift) + (rewrite + (ShiftExpr (PRINT a b) x0 x1) + (PRINT (ShiftOperand a x0 x1) (ShiftOperand b x0 x1)) + :ruleset shift) + + (rule ((= f (ShiftOperand (Arg x) last-unshifted amt)) (<= x last-unshifted)) + ((union f (Arg x))) :ruleset shift) + (rule ((= f (ShiftOperand (Arg x) last-unshifted amt)) (> x last-unshifted)) + ((union f (Arg (+ x amt)))) :ruleset shift) + + (rewrite + (ShiftOperand (Node b) x0 x1) + (Node (ShiftBody b x0 x1)) + :ruleset shift) + (rewrite + (ShiftOperand (Project i b) x0 x1) + (Project i (ShiftBody b x0 x1)) + :ruleset shift) + + (rewrite + (ShiftBody (PureOp e) x0 x1) + (PureOp (ShiftExpr e x0 x1)) + :ruleset shift) + ;; Don't cross regions, so so we shift into the inputs but not outputs + ;; A Gamma's pred is on the outside, so it's affected, but not a Theta's + (rewrite + (ShiftBody (Gamma pred inputs outputs) x0 x1) + (Gamma + (ShiftOperand pred x0 x1) + (ShiftVecOperand inputs x0 x1) + outputs) + :ruleset shift) + (rewrite + (ShiftBody (Theta pred inputs outputs) x0 x1) + (Theta pred (ShiftVecOperand inputs x0 x1) outputs) + :ruleset shift) + + (function ShiftVecOperand-helper (VecOperand i64 i64 i64) VecOperand) + (rewrite + (ShiftVecOperand vec x0 x1) + (ShiftVecOperand-helper vec x0 x1 0) + :ruleset shift) + (rule + ((= f (ShiftVecOperand-helper (VO vec) x0 x1 i)) + (< i (vec-length vec))) + ((union + (ShiftVecOperand-helper (VO vec) x0 x1 i) + (ShiftVecOperand-helper + (VO (vec-set vec i (ShiftOperand (vec-get vec i) x0 x1))) + x0 x1 (+ i 1)))) + :ruleset shift) + (rule + ((= f (ShiftVecOperand-helper (VO vec) x0 x1 i)) + (= i (vec-length vec))) + ((union + (ShiftVecOperand-helper (VO vec) x0 x1 i) + (VO vec))) + :ruleset shift) + + (function ShiftVecVecOperand-helper (VecVecOperand i64 i64 i64) VecVecOperand) + (rewrite + (ShiftVecVecOperand vec x0 x1) + (ShiftVecVecOperand-helper vec x0 x1 0) + :ruleset shift) + (rule + ((= f (ShiftVecVecOperand-helper (VVO vec) x0 x1 i)) + (< i (vec-length vec))) + ((union + (ShiftVecVecOperand-helper (VVO vec) x0 x1 i) + (ShiftVecVecOperand-helper + (VVO (vec-set vec i (ShiftVecOperand (vec-get vec i) x0 x1))) + x0 x1 (+ i 1)))) + :ruleset shift) + (rule + ((= f (ShiftVecVecOperand-helper (VVO vec) x0 x1 i)) + (= i (vec-length vec))) + ((union + (ShiftVecVecOperand-helper (VVO vec) x0 x1 i) + (VVO vec))) + :ruleset shift) +;; #################################### +;; implementation of PassThroughArguments +;; Creates a vec of arguments +;; (vec-of (Arg 0) (Arg 1) ...) with length i +(function PassThroughArguments (i64) VecOperand :unextractable) + + + +;; (how many arguments to generate, vector so far) +(function PassThroughArgumentsHelper (i64 VecOperand) VecOperand :unextractable) + +(rewrite (PassThroughArguments i) + (PassThroughArgumentsHelper i (VO (vec-of))) + :ruleset subst) + +(rule ((= lhs (PassThroughArgumentsHelper i (VO rest))) + (< (vec-length rest) i)) + ((union lhs + (PassThroughArgumentsHelper i + (VO (vec-push rest (Arg (vec-length rest))))))) + :ruleset subst) + +(rule ((= lhs (PassThroughArgumentsHelper i (VO rest))) + (= (vec-length rest) i)) + ((union lhs (VO rest))) + :ruleset subst) + + + +;; Project each argument out of a body +(function BodyToVecOperand (i64 Body) VecOperand :unextractable) +;; current index, body length, body, and vector so far +(function BodyToVecOperandHelper (i64 i64 Body VecOperandBase) VecOperand :unextractable) + +(rewrite (BodyToVecOperand body-len body) + (BodyToVecOperandHelper 0 body-len body (vec-of))) +(rule + ((= helper (BodyToVecOperandHelper index body-len body so-far)) + (< index body-len)) + ((union helper + (BodyToVecOperandHelper (+ index 1) body-len body + (vec-push so-far + (Project index body))))) + :ruleset subst) + +(rule + ((= helper (BodyToVecOperandHelper index body-len body so-far)) + (= index body-len)) + ((union helper (VO so-far))) + :ruleset subst) + + + +;; constant_fold.rs adds most constant folding operations +;; this file is for special cases + + +;; eliminate gamma nodes for true and false cases +(rule ((= gamma + ;; gamma predicate is true + (Gamma (Node (PureOp (Const (BoolT) (const) (Bool true)))) + inputs + (VVO outputs)))) + ( + ;; replace use of the gamma with + ;; the true case + (union + gamma + (OperandGroup + (SubstVecOperandAll + (vec-get outputs 1) + inputs))))) + + + +(rule ((= gamma + ;; gamma predicate is false + (Gamma (Node (PureOp (Const (BoolT) (const) (Bool false)))) + inputs + (VVO outputs)))) + ( + ;; replace use of the gamma with + ;; the false case + (union + gamma + (OperandGroup + (SubstVecOperandAll (vec-get outputs 0) inputs))))) + +;; Eliminate theta +;; Unroll one layer and get rid of loop +(rule ((= theta + ;; gamma predicate is false + (Theta (Node (PureOp (Const (BoolT) (const) (Bool false)))) + (VO inputs) + (VO outputs)))) + ((let after-one-iter (SubstVecOperandAll (VO outputs) (VO inputs))) + (union theta + (OperandGroup after-one-iter)))) + + + + + +(rewrite (badd output_type + (Node (PureOp (Const ty2 (const) (Num n1)))) + (Node (PureOp (Const ty3 (const) (Num n2))))) + (Const output_type (const) (Num (+ n1 n2)))) +(rewrite (bsub output_type + (Node (PureOp (Const ty2 (const) (Num n1)))) + (Node (PureOp (Const ty3 (const) (Num n2))))) + (Const output_type (const) (Num (- n1 n2)))) +(rewrite (bmul output_type + (Node (PureOp (Const ty2 (const) (Num n1)))) + (Node (PureOp (Const ty3 (const) (Num n2))))) + (Const output_type (const) (Num (* n1 n2)))) +(rewrite (bdiv output_type + (Node (PureOp (Const ty2 (const) (Num n1)))) + (Node (PureOp (Const ty3 (const) (Num n2))))) + (Const output_type (const) (Num (/ n1 n2)))) +(rewrite (blt output_type + (Node (PureOp (Const ty2 (const) (Num n1)))) + (Node (PureOp (Const ty3 (const) (Num n2))))) + (Const output_type (const) (Bool (bool-< n1 n2)))) +(sort TermAndCost) +(function Smaller (TermAndCost TermAndCost) TermAndCost) + +;; manual, bottom-up extraction of terms using this function +(function ExtractedExpr (Expr) TermAndCost + :merge (Smaller old new)) +;; Store a term and its cost for this type +(function ExprAndCost (Expr i64) TermAndCost) + +;; Perform smaller using the next two rules +(rule ((= lhs (Smaller (ExprAndCost t1 cost1) + (ExprAndCost t2 cost2))) + (<= cost1 cost2)) + ((union lhs (ExprAndCost t1 cost1))) + :ruleset fast-analyses) + +(rule ((= lhs (Smaller (ExprAndCost t1 cost1) + (ExprAndCost t2 cost2))) + (> cost1 cost2)) + ((union lhs (ExprAndCost t2 cost2))) + :ruleset fast-analyses) + + +;; manual, bottom-up extraction of terms using this function +(function ExtractedOperand (Operand) TermAndCost + :merge (Smaller old new)) +;; Store a term and its cost for this type +(function OperandAndCost (Operand i64) TermAndCost) + +;; Perform smaller using the next two rules +(rule ((= lhs (Smaller (OperandAndCost t1 cost1) + (OperandAndCost t2 cost2))) + (<= cost1 cost2)) + ((union lhs (OperandAndCost t1 cost1))) + :ruleset fast-analyses) + +(rule ((= lhs (Smaller (OperandAndCost t1 cost1) + (OperandAndCost t2 cost2))) + (> cost1 cost2)) + ((union lhs (OperandAndCost t2 cost2))) + :ruleset fast-analyses) + + +;; manual, bottom-up extraction of terms using this function +(function ExtractedBody (Body) TermAndCost + :merge (Smaller old new)) +;; Store a term and its cost for this type +(function BodyAndCost (Body i64) TermAndCost) + +;; Perform smaller using the next two rules +(rule ((= lhs (Smaller (BodyAndCost t1 cost1) + (BodyAndCost t2 cost2))) + (<= cost1 cost2)) + ((union lhs (BodyAndCost t1 cost1))) + :ruleset fast-analyses) + +(rule ((= lhs (Smaller (BodyAndCost t1 cost1) + (BodyAndCost t2 cost2))) + (> cost1 cost2)) + ((union lhs (BodyAndCost t2 cost2))) + :ruleset fast-analyses) + + +;; manual, bottom-up extraction of terms using this function +(function ExtractedVecOperand (VecOperand) TermAndCost + :merge (Smaller old new)) +;; Store a term and its cost for this type +(function VecOperandAndCost (VecOperand i64) TermAndCost) + +;; Perform smaller using the next two rules +(rule ((= lhs (Smaller (VecOperandAndCost t1 cost1) + (VecOperandAndCost t2 cost2))) + (<= cost1 cost2)) + ((union lhs (VecOperandAndCost t1 cost1))) + :ruleset fast-analyses) + +(rule ((= lhs (Smaller (VecOperandAndCost t1 cost1) + (VecOperandAndCost t2 cost2))) + (> cost1 cost2)) + ((union lhs (VecOperandAndCost t2 cost2))) + :ruleset fast-analyses) + + +;; manual, bottom-up extraction of terms using this function +(function ExtractedVecVecOperand (VecVecOperand) TermAndCost + :merge (Smaller old new)) +;; Store a term and its cost for this type +(function VecVecOperandAndCost (VecVecOperand i64) TermAndCost) + +;; Perform smaller using the next two rules +(rule ((= lhs (Smaller (VecVecOperandAndCost t1 cost1) + (VecVecOperandAndCost t2 cost2))) + (<= cost1 cost2)) + ((union lhs (VecVecOperandAndCost t1 cost1))) + :ruleset fast-analyses) + +(rule ((= lhs (Smaller (VecVecOperandAndCost t1 cost1) + (VecVecOperandAndCost t2 cost2))) + (> cost1 cost2)) + ((union lhs (VecVecOperandAndCost t2 cost2))) + :ruleset fast-analyses) + + +(rule ((= lhs (badd ty a b)) + (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) + (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) + ((set (ExtractedExpr lhs) + (ExprAndCost (badd ty expr1 expr2) + (+ 1 (+ cost1 cost2))))) + :ruleset fast-analyses) + + +(rule ((= lhs (bsub ty a b)) + (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) + (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) + ((set (ExtractedExpr lhs) + (ExprAndCost (bsub ty expr1 expr2) + (+ 1 (+ cost1 cost2))))) + :ruleset fast-analyses) + + +(rule ((= lhs (bmul ty a b)) + (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) + (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) + ((set (ExtractedExpr lhs) + (ExprAndCost (bmul ty expr1 expr2) + (+ 1 (+ cost1 cost2))))) + :ruleset fast-analyses) + + +(rule ((= lhs (bdiv ty a b)) + (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) + (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) + ((set (ExtractedExpr lhs) + (ExprAndCost (bdiv ty expr1 expr2) + (+ 1 (+ cost1 cost2))))) + :ruleset fast-analyses) + + +(rule ((= lhs (blt ty a b)) + (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) + (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) + ((set (ExtractedExpr lhs) + (ExprAndCost (blt ty expr1 expr2) + (+ 1 (+ cost1 cost2))))) + :ruleset fast-analyses) + + +(rule ((= lhs (PRINT a b)) + (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) + (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) + ((set (ExtractedExpr lhs) + (ExprAndCost (PRINT expr1 expr2) + (+ 1 (+ cost1 cost2))))) + :ruleset fast-analyses) + +;; TODO fix this HACK +;; this is how we get an empty vector of vectors in egglog because of +;; typechecking bug in egglog https://github.com/egraphs-good/egglog/issues/113 +(let empty-vvo + (vec-pop (vec-of (VO (vec-of))))) + + +(function ExtractedVecOperandHelper (VecOperand i64) TermAndCost :merge (Smaller old new)) + +;; base case: extract nothing +(rule + ((VO vec)) + ((set (ExtractedVecOperandHelper (VO vec) 0) + (VecOperandAndCost (VO (vec-of)) 0))) + :ruleset fast-analyses) + +;; extract one more thing +(rule + ((= (VecOperandAndCost (VO current) current-cost) + (ExtractedVecOperandHelper (VO vec) index)) + (< index (vec-length vec)) + (= (ExtractedOperand (VecOperand-get (VO vec) index)) (OperandAndCost expr expr-cost))) + ((set (ExtractedVecOperandHelper (VO vec) (+ index 1)) + (VecOperandAndCost + (VO (vec-push current expr)) + (+ current-cost expr-cost)))) + :ruleset fast-analyses) + + + +;; finished extracting, create result +(rule + ((= result + (ExtractedVecOperandHelper (VO vec) index)) + ;; at the end + (= index (vec-length vec))) + ((set (ExtractedVecOperand (VO vec)) + result)) + :ruleset fast-analyses) + + +(function ExtractedVecVecOperandHelper (VecVecOperand i64) TermAndCost :merge (Smaller old new)) + +;; base case: extract nothing +(rule + ((VVO vec)) + ((set (ExtractedVecVecOperandHelper (VVO vec) 0) + (VecVecOperandAndCost (VVO empty-vvo) 0))) + :ruleset fast-analyses) + +;; extract one more thing +(rule + ((= (VecVecOperandAndCost (VVO current) current-cost) + (ExtractedVecVecOperandHelper (VVO vec) index)) + (< index (vec-length vec)) + (= (ExtractedVecOperand (VecVecOperand-get (VVO vec) index)) (VecOperandAndCost expr expr-cost))) + ((set (ExtractedVecVecOperandHelper (VVO vec) (+ index 1)) + (VecVecOperandAndCost + (VVO (vec-push current expr)) + (+ current-cost expr-cost)))) + :ruleset fast-analyses) + + + +;; finished extracting, create result +(rule + ((= result + (ExtractedVecVecOperandHelper (VVO vec) index)) + ;; at the end + (= index (vec-length vec))) + ((set (ExtractedVecVecOperand (VVO vec)) + result)) + :ruleset fast-analyses) + + +;; Constant gets cost of 1 +(rule + ((= lhs (Const ty ops lit))) + ((set (ExtractedExpr lhs) (ExprAndCost lhs 1))) + :ruleset fast-analyses) + +;; arg gets cost of 1 +(rule + ((= lhs (Arg index))) + ((set (ExtractedOperand lhs) (OperandAndCost lhs 1))) + :ruleset fast-analyses) + + +;; PureOp doesn't add cost +(rule + ((= lhs (PureOp expr)) + (= (ExprAndCost expr-extracted expr-cost) + (ExtractedExpr expr))) + ((set (ExtractedBody lhs) (BodyAndCost (PureOp expr-extracted) expr-cost))) + :ruleset fast-analyses) + +;; Nor does Node +(rule + ((= lhs (Node body)) + (= (BodyAndCost body-extracted body-cost) + (ExtractedBody body))) + ((set (ExtractedOperand lhs) (OperandAndCost (Node body-extracted) body-cost))) + :ruleset fast-analyses) + +;; Theta gets a cost of 1 for now +(rule + ((= lhs (Theta pred inputs outputs)) + (= (OperandAndCost pred-extracted pred-cost) + (ExtractedOperand pred)) + (= (VecOperandAndCost inputs-extracted inputs-cost) + (ExtractedVecOperand inputs)) + (= (VecOperandAndCost outputs-extracted outputs-cost) + (ExtractedVecOperand outputs))) + ((set (ExtractedBody lhs) + (BodyAndCost + (Theta pred-extracted inputs-extracted outputs-extracted) + (+ 1 (+ pred-cost (+ inputs-cost outputs-cost)))))) + :ruleset fast-analyses) + +;; Gamma gets a cost of 1 for now +(rule + ((= lhs (Gamma pred inputs outputs)) + (= (OperandAndCost pred-extracted pred-cost) + (ExtractedOperand pred)) + (= (VecOperandAndCost inputs-extracted inputs-cost) + (ExtractedVecOperand inputs)) + (= (VecVecOperandAndCost outputs-extracted outputs-cost) + (ExtractedVecVecOperand outputs))) + ((set (ExtractedBody lhs) + (BodyAndCost + (Gamma pred-extracted inputs-extracted outputs-extracted) + (+ 1 (+ pred-cost (+ inputs-cost outputs-cost)))))) + :ruleset fast-analyses) + + +;; Project is also free +(rule ((= lhs (Project index body)) + (= (BodyAndCost body-extracted body-cost) + (ExtractedBody body))) + ((set (ExtractedOperand lhs) + (OperandAndCost (Project index body-extracted) body-cost))) + :ruleset fast-analyses) + + + +;; If a theta passes along argument, +;; can extract the input instead. +(rule ((= lhs (Project index loop)) + (= loop (Theta pred inputs outputs)) + (= (VecOperand-get outputs index) (Arg index)) + (= passedthrough (ExtractedOperand (VecOperand-get inputs index))) + ) + ((set (ExtractedOperand lhs) passedthrough)) + :ruleset fast-analyses) + +;; If a gamma passes along an argument in both branches, +;; extract the input instead. +(rule ((= lhs (Project index loop)) + (= loop (Gamma pred inputs outputs)) + (= outputs (VVO outputs-inner)) + (= 2 (vec-length outputs-inner)) + (= outputs0 (VecVecOperand-get outputs 0)) + (= outputs1 (VecVecOperand-get outputs 1)) + (= (VecOperand-get outputs0 index) (Arg index)) + (= (VecOperand-get outputs1 index) (Arg index)) + (= passedthrough (ExtractedOperand (VecOperand-get inputs index)))) + ((set (ExtractedOperand lhs) passedthrough)) + :ruleset fast-analyses) + + +;; if we reach a new context, union +(rule ((= theta (Theta pred inputs outputs)) + (= (BodyAndCost extracted cost) + (ExtractedBody theta))) + ((union theta extracted)) + :ruleset fast-analyses) +(rule ((= gamma (Gamma pred inputs outputs)) + (= (BodyAndCost extracted cost) + (ExtractedBody gamma))) + ((union gamma extracted)) + :ruleset fast-analyses) + + +;; if we reach the function at the top level, union +(rule ((= func (Func name intypes outtypes body)) + (= (VecOperandAndCost extracted cost) + (ExtractedVecOperand body))) + ((union func + (Func name intypes outtypes extracted))) + :ruleset fast-analyses) + +;; if a && b: +;; A +;; else: +;; B +;; ---------- +;; if a: +;; if b: +;; A +;; else: +;; B +;; else: +;; B +(rule ((= gamma (Gamma (Node (PureOp (band BoolT a b))) (VO inputs) (VVO outputs))) + (= (vec-length outputs) 2) + (= (vec-get outputs 1) (VO A)) + (= (vec-get outputs 0) (VO B)) + (= args (vec-length inputs)) + (= rets (vec-length B))) + ((let inner (Gamma (Arg args) ; we pass b as an extra argument to the outer gamma + (PassThroughArguments args) + (VVO (vec-of (VO B) + (VO A))))) + (union gamma (Gamma a + (VO (vec-push inputs b)) ; pass b as an extra argument + (VVO (vec-of (VO B) + (BodyToVecOperand rets inner))))))) + +;; if a || b: +;; A +;; else: +;; B +;; ----------- +;; if a: +;; A +;; else: +;; if b: +;; A +;; else: +;; B +(rule ((= gamma (Gamma (Node (PureOp (bor BoolT a b))) (VO inputs) (VVO outputs))) + (= (vec-length outputs) 2) + (= (vec-get outputs 1) (VO A)) + (= (vec-get outputs 0) (VO B)) + (= args (vec-length inputs)) + (= rets (vec-length B))) + ((let inner (Gamma (Arg args) ; we pass b as an extra argument to the outer gamma + (PassThroughArguments args) + (VVO (vec-of (VO B) + (VO A))))) + (union gamma (Gamma a + (VO (vec-push inputs b)) ; pass b as an extra argument + (VVO (vec-of (BodyToVecOperand rets inner) + (VO A))))))) + +;; if a: +;; A +;; else: +;; A +;; ------ +;; A +(rule ((= gamma (Gamma condition inputs (VVO outputs))) + (= (vec-length outputs) 2) + (= (vec-get outputs 0) (vec-get outputs 1))) + ((union gamma (OperandGroup (SubstVecOperandAll (vec-get outputs 0) inputs))))) + + +;; unroll loops +(rule ((= theta (Theta pred (VO inputs) (VO outputs)))) + ;; arguments body + ((let after-one-iter + (SubstVecOperandAll (VO outputs) (VO inputs))) + ;; (vec-of (Arg 0) (Arg 1) ...) + (let pass-through (PassThroughArguments (vec-length outputs))) + (union theta + (Gamma + (SubstOperandAll pred after-one-iter) + after-one-iter + (VVO + (vec-of + ;; in the false case, we are done + pass-through + ;; otherwise do the rest of the loop + (BodyToVecOperand + (vec-length outputs) + (Theta pred pass-through + (VO outputs))))))))) + + + +(datatype Interval + (BoolI bool bool) + (IntI i64 i64) + (interval-intersect Interval Interval) + (interval-union Interval Interval)) + + +(rewrite (interval-intersect (IntI la ha) (IntI lb hb)) + (IntI (max la lb) (min ha hb))) +(rewrite (interval-union (IntI la ha) (IntI lb hb)) + (IntI (min la lb) (max ha hb))) + +(rewrite (interval-intersect (BoolI la ha) (BoolI lb hb)) + (BoolI (or la lb) (and ha hb))) +(rewrite (interval-union (BoolI la ha) (BoolI lb hb)) + (BoolI (and la lb) (or ha hb))) + +(function ival (Operand) Interval + :merge (interval-intersect old new)) + +; context-specific intervals (because Args need to have interval analysis but are not globally unique) +(function context-ival (Operand Body) Interval + :merge (interval-intersect old new)) + +(rule ((= lhs (Node (PureOp (Const (BoolT) (const) (Bool b)))))) + ((set (ival lhs) (BoolI b b)))) + +(rule ((= lhs (Node (PureOp (Const (IntT) (const) (Num n)))))) + ((set (ival lhs) (IntI n n)))) + + +; < a b interval (< ha lb) (< la hb) +(rule ((= lhs (Node (PureOp (blt (BoolT) a b)))) + (= (IntI la ha) (ival a)) + (= (IntI lb hb) (ival b))) + ((set (ival lhs) (BoolI (bool-< ha lb) (bool-< la hb))))) + +; Rule that unions intervals for a gamma +(rule ( + (= lhs (Project i (Gamma pred ins (VVO outs)))) + (= (VO thens) (vec-get outs 1)) + (= (VO elses) (vec-get outs 0)) + (= thenival (ival (vec-get thens i))) + (= elseival (ival (vec-get elses i))) + ) + ( + (set (ival lhs) (interval-union thenival elseival)) + ) +) + +; Eliminate gamma with interval analysis +(rule ( + (= gamma (Gamma pred inputs (VVO outputs))) + (= (BoolI true true) (ival pred)) + ) + ( + (union gamma (OperandGroup (SubstVecOperandAll (vec-get outputs 1) inputs))) + ) +) +(rule ( + (= gamma (Gamma pred inputs (VVO outputs))) + (= (BoolI false false) (ival pred)) + ) + ( + (union gamma (OperandGroup (SubstVecOperandAll (vec-get outputs 0) inputs))) + ) +) + +(rule + ( + ; Match on PureOp because all exprs are converted to bodies + ; Will refactor Call in the future + (= return (PureOp (Call ty name args num)) ) + (Func name input-types output-types body) + ) + (( + union + return + (OperandGroup (SubstVecOperandAll body args)) + )) +) + + (rule + ((= num (Node (PureOp (Const (IntT) (const) (Num n1))))) + (= lhs (badd (IntT) other num))) + ((union lhs (badd (IntT) num other)))) + + (rule + ((= num (Node (PureOp (Const (IntT) (const) (Num n1))))) + (= lhs (bmul (IntT) other num))) + ((union lhs (bmul (IntT) num other)))) + + (rule + ((= lhs (badd (IntT) + (Node (PureOp (badd (IntT) a b))) + c))) + ((union lhs + (badd (IntT) + a + (Node (PureOp (badd (IntT) b c))))))) + + + (rule + ((= lhs (badd (IntT) + a + (Node (PureOp (badd (IntT) b c))))) + (= b (Node (PureOp (Const (IntT) (const) (Num n1))))) + ) + ((union lhs + (badd (IntT) + b + (Node (PureOp (badd (IntT) a c)))))) + ) + + + (rule + ((= lhs (badd (IntT) + a + (Node (PureOp (badd (IntT) b c))))) + (= a (Node (PureOp (Const (IntT) (const) (Num n1))))) + (= b (Node (PureOp (Const (IntT) (const) (Num n2)))))) + + ((union lhs + (badd (IntT) + (Node (PureOp (Const (IntT) (const) (Num (+ n1 n2))))) + c)))) + + +(let v0 "main") +(let v1 (IntT)) +(let v2 (Bril v1)) +(let v3 (PrintState)) +(let v4 (vec-of v2 v2 v3)) +(let v5 (vec-of v3)) +(let v6 1) +(let v7 2) +(let v8 (BoolT)) +(let v9 (Arg v6)) +(let v10 4) +(let v11 (Arg v10)) +(let v12 (blt v8 v9 v11)) +(let v13 (PureOp v12)) +(let v14 (Node v13)) +(let v15 0) +(let v16 (Arg v15)) +(let v17 (Arg v7)) +(let v18 3) +(let v19 (Arg v18)) +(let v20 (vec-of v16 v9 v17 v19 v11)) +(let v21 (VO v20)) +(let v22 (const)) +(let v23 (Num v15)) +(let v24 (Const v1 v22 v23)) +(let v25 (PureOp v24)) +(let v26 (Node v25)) +(let v27 (vec-of v16 v9 v26 v17 v19 v11)) +(let v28 (VO v27)) +(let v29 (blt v8 v19 v11)) +(let v30 (PureOp v29)) +(let v31 (Node v30)) +(let v32 5) +(let v33 (Arg v32)) +(let v34 (vec-of v16 v9 v17 v19 v11 v33)) +(let v35 (VO v34)) +(let v36 (vec-of v16 v9 v17 v26 v19 v11 v33)) +(let v37 (VO v36)) +(let v38 (bmul v1 v9 v11)) +(let v39 (PureOp v38)) +(let v40 (Node v39)) +(let v41 (badd v1 v40 v19)) +(let v42 (PureOp v41)) +(let v43 (Node v42)) +(let v44 (PRINT v43 v16)) +(let v45 (PureOp v44)) +(let v46 (Node v45)) +(let v47 (Num v6)) +(let v48 (Const v1 v22 v47)) +(let v49 (PureOp v48)) +(let v50 (Node v49)) +(let v51 (badd v1 v19 v17)) +(let v52 (PureOp v51)) +(let v53 (Node v52)) +(let v54 (vec-of v46 v9 v17 v50 v53 v11 v33)) +(let v55 (VO v54)) +(let v56 (vec-of v37 v55)) +(let v57 (VVO v56)) +(let v58 (Gamma v31 v35 v57)) +(let v59 (Project v18 v58)) +(let v60 (vec-of v16 v9 v17 v26 v19 v11)) +(let v61 (VO v60)) +(let v62 (Project v15 v58)) +(let v63 (Project v6 v58)) +(let v64 (Project v7 v58)) +(let v65 (Project v10 v58)) +(let v66 (Project v32 v58)) +(let v67 6) +(let v68 (Project v67 v58)) +(let v69 (vec-of v62 v63 v64 v65 v66 v68)) +(let v70 (VO v69)) +(let v71 (Theta v59 v61 v70)) +(let v72 (Project v15 v71)) +(let v73 (Project v6 v71)) +(let v74 (Project v7 v71)) +(let v75 (badd v1 v73 v74)) +(let v76 (PureOp v75)) +(let v77 (Node v76)) +(let v78 (Project v10 v71)) +(let v79 (Project v32 v71)) +(let v80 (vec-of v72 v77 v50 v74 v78 v79)) +(let v81 (VO v80)) +(let v82 (vec-of v28 v81)) +(let v83 (VVO v82)) +(let v84 (Gamma v14 v21 v83)) +(let v85 (Project v7 v84)) +(let v86 (vec-of v17 v26 v50 v9 v16)) +(let v87 (VO v86)) +(let v88 (Project v15 v84)) +(let v89 (Project v6 v84)) +(let v90 (Project v18 v84)) +(let v91 (Project v10 v84)) +(let v92 (Project v32 v84)) +(let v93 (vec-of v88 v89 v90 v91 v92)) +(let v94 (VO v93)) +(let v95 (Theta v85 v87 v94)) +(let v96 (Project v6 v95)) +(let v97 (Project v15 v95)) +(let v98 (PRINT v96 v97)) +(let v99 (PureOp v98)) +(let v100 (Node v99)) +(let v101 (vec-of v100)) +(let v102 (VO v101)) +(let v103 (Func v0 v4 v5 v102)) + +(run-schedule + ; only repeating twice to reduce benchmark CI performance + ; increasing to 3 times will change benchmark time from 4 minutes to 40+ minutes + (repeat 2 (saturate fast-analyses) + (run) + (saturate subst))) diff --git a/tests/eqsat-basic-multiset.egg b/tests/eqsat-basic-multiset.egg new file mode 100644 index 0000000..e4a9fa0 --- /dev/null +++ b/tests/eqsat-basic-multiset.egg @@ -0,0 +1,124 @@ +;; Example showing how to use multisets to hold associative & commutative operations + +(datatype* + (Math + (Num i64) + (Var String) + (Add Math Math) + (Mul Math Math) + (Product MathMultiSet) + (Sum MathMultiSet)) + (sort MathToMath (UnstableFn (Math) Math)) + (sort MathMultiSet (MultiSet Math))) + +;; expr1 = 2 * (x + 3) +(let expr1 (Mul (Num 2) (Add (Var "x") (Num 3)))) +;; expr2 = 6 + 2 * x +(let expr2 (Add (Num 6) (Mul (Num 2) (Var "x")))) + +(rewrite (Add a b) (Sum (multiset-of a b))) +(rewrite (Mul a b) (Product (multiset-of a b))) + +;; 0 or 1 elements sums/products also can be extracted back to numbers +(rule + ( + (= sum (Sum sum-inner)) + (= 0 (multiset-length sum-inner)) + ) + ((union sum (Num 0))) +) +(rule + ( + (= sum (Sum sum-inner)) + (= 1 (multiset-length sum-inner)) + ) + ((union sum (multiset-pick sum-inner))) +) + +(rule + ( + (= product (Product product-inner)) + (= 0 (multiset-length product-inner)) + ) + ((union product (Num 1))) +) +(rule + ( + (= product (Product product-inner)) + (= 1 (multiset-length product-inner)) + ) + ((union product (multiset-pick product-inner))) +) + +; (rewrite (Mul a (Add b c)) +; (Add (Mul a b) (Mul a c))) + +; -> we would like to write it like this, but cannot (yet) bc we can't match on the inner structure of the multisets +; and we don't support anonymous functions + +; (rewrite (Product (multiset-insert a (Sum bc))) +; (Sum (multiset-map (lambda (x) (Product (multiset-insert a x))) bc))) + + +;; so instead we can define a function and partially apply it to get the same function as the lambda +(function tmp-fn (MathMultiSet Math) Math) +(rewrite (tmp-fn xs x) (Product (multiset-insert xs x))) + +(rule + ( + ;; and we can do a cross product search of all possible pairs of products/sums to find one we want + (= sum (Sum bc)) + (= product (Product product-inner)) + (multiset-contains product-inner sum) + (> (multiset-length product-inner) 1) + (= a (multiset-remove product-inner sum)) + ) + ( + (union product (Sum + (unstable-multiset-map + (unstable-fn "tmp-fn" a) + bc) + )) + ) +) + +; (rewrite (Add (Num a) (Num b)) +; (Num (+ a b))) + +(rule + ( + (= sum (Sum sum-inner)) + (= num-a (Num a)) + (multiset-contains sum-inner num-a) + (= without-a (multiset-remove sum-inner num-a)) + (= num-b (Num b)) + (multiset-contains without-a num-b) + ) + ( + (union sum + (Sum (multiset-insert (multiset-remove without-a num-b) (Num (+ a b)))) + ) + ) +) + +; (rewrite (Mul (Num a) (Num b)) +; (Num (* a b))) + +(rule + ( + (= product (Product product-inner)) + (= num-a (Num a)) + (multiset-contains product-inner num-a) + (= without-a (multiset-remove product-inner num-a)) + (= num-b (Num b)) + (multiset-contains without-a num-b) + ) + ( + (union product + (Product (multiset-insert (multiset-remove without-a num-b) (Num (* a b)))) + ) + ) +) + +(run 100) +(check (= expr1 expr2)) diff --git a/tests/eqsat-basic.egg b/tests/eqsat-basic.egg new file mode 100644 index 0000000..4831dbf --- /dev/null +++ b/tests/eqsat-basic.egg @@ -0,0 +1,25 @@ +(datatype Math + (Num i64) + (Var String) + (Add Math Math) + (Mul Math Math)) + +;; expr1 = 2 * (x + 3) +(let expr1 (Mul (Num 2) (Add (Var "x") (Num 3)))) +;; expr2 = 6 + 2 * x +(let expr2 (Add (Num 6) (Mul (Num 2) (Var "x")))) + + +;; (rule ((= __root (Add a b))) +;; ((union __root (Add b a))) +(rewrite (Add a b) + (Add b a)) +(rewrite (Mul a (Add b c)) + (Add (Mul a b) (Mul a c))) +(rewrite (Add (Num a) (Num b)) + (Num (+ a b))) +(rewrite (Mul (Num a) (Num b)) + (Num (* a b))) + +(run 10) +(check (= expr1 expr2)) diff --git a/tests/eqsolve.egg b/tests/eqsolve.egg new file mode 100644 index 0000000..065528f --- /dev/null +++ b/tests/eqsolve.egg @@ -0,0 +1,45 @@ +(datatype Expr + (Add Expr Expr) + (Neg Expr) + (Num i64) + (Mul Expr Expr) + (Var String) +) + +(rewrite (Add x y) (Add y x)) +(rewrite (Add (Add x y) z) (Add x (Add y z))) +(rewrite (Add (Num x) (Num y)) (Num (+ x y))) +(rule ((= (Add x y) z)) + ((union (Add z (Neg y)) x))) +(rewrite (Neg (Neg x)) x) +(rewrite (Neg (Num n)) (Num (- 0 n))) + +(rule ((= x (Var v))) ((union (Mul (Num 1) x) x))) +(rule ((= x (Add x1 x2))) ((union (Mul (Num 1) x) x))) +(rewrite (Add (Mul y x) (Mul z x)) (Mul (Add y z) x)) +(rewrite (Mul x y) (Mul y x)) +(rule ((= (Mul (Num x) y) (Num z)) + (= (% z x) 0)) + ((union y (Num (/ z x))))) + +; system 1: x + 2 = 7 +(union (Add (Var "x") (Num 2)) (Num 7)) +; system 2: z + y = 6, 2z = y +(union (Add (Var "z") (Var "y")) (Num 6)) +(union (Add (Var "z") (Var "z")) (Var "y")) + +(run 5) +(query-extract (Var "x")) +(query-extract (Var "y")) +(query-extract (Var "z")) +(check (= (Var "z") (Add (Num 6) (Neg (Var "y"))))) +(check (= (Var "y") (Add (Add (Num 6) (Neg (Var "y"))) (Add (Num 6) (Neg (Var "y")))))) +(check (= (Var "y") (Add (Add (Num 12) (Neg (Var "y"))) (Neg (Var "y"))))) +(check (= (Add (Var "y") (Var "y")) + (Add (Num 12) (Neg (Var "y"))))) +(check (= (Add (Add (Var "y") (Var "y")) (Var "y")) + (Num 12))) +(check (= (Add (Mul (Num 2) (Var "y")) (Var "y")) + (Num 12))) +(check (= (Mul (Num 3) (Var "y")) + (Num 12))) diff --git a/tests/f64.egg b/tests/f64.egg new file mode 100644 index 0000000..23301bf --- /dev/null +++ b/tests/f64.egg @@ -0,0 +1,13 @@ +(check (= (neg 1.5) -1.5)) +(check (= (+ 1.5 9.2) 10.7)) +(check (= (/ 12.5 2.0) 6.25)) +(check (< 1.5 9.2)) +(check (>= 9.2 1.5)) +(check (= (^ 9.0 2.5) 243.0)) +(fail (check (= (^ 4.0 2.5) 31.99))) +(fail (check (< 9.2 1.5))) +(fail (check (= (+ 1.5 9.2) 10.6))) +(check (= (to-f64 1) 1.0)) +(check (= (to-i64 1.0) 1)) +(check (= (to-string 1.2) "1.2")) +(check (= (to-string 1.0) "1.0")) diff --git a/tests/fail-typecheck/repro-containers-disallowed.egg b/tests/fail-typecheck/repro-containers-disallowed.egg new file mode 100644 index 0000000..ed76d3a --- /dev/null +++ b/tests/fail-typecheck/repro-containers-disallowed.egg @@ -0,0 +1,4 @@ +(sort IVec (Vec i64)) + +; Test vec-of +(fail (check (= (vec-of 1 2) (vec-push (vec-push (vec-empty) 1) 2)))) diff --git a/tests/fail-typecheck/repro-duplicated-var.egg b/tests/fail-typecheck/repro-duplicated-var.egg new file mode 100644 index 0000000..2340aa7 --- /dev/null +++ b/tests/fail-typecheck/repro-duplicated-var.egg @@ -0,0 +1,3 @@ +(function f (i64) i64) +;; the let's y should fail checking +(rule ((= x 1) (= y x)) ((let y (f 1)) (set (f 0) 0))) \ No newline at end of file diff --git a/tests/fail-typecheck/unbound.egg b/tests/fail-typecheck/unbound.egg new file mode 100644 index 0000000..d537a32 --- /dev/null +++ b/tests/fail-typecheck/unbound.egg @@ -0,0 +1,6 @@ +(datatype Math + (Add Math Math) + (Sub Math Math) +) + +(rule ((= e (Add x y))) ((Add x i))) diff --git a/tests/fail-typecheck/unstable-fn-wrong-args-type.egg b/tests/fail-typecheck/unstable-fn-wrong-args-type.egg new file mode 100644 index 0000000..ab109e4 --- /dev/null +++ b/tests/fail-typecheck/unstable-fn-wrong-args-type.egg @@ -0,0 +1,8 @@ +;; test that you can't resolve a function with the wrong type of args + +(datatype Math + (Zero) + (Inc Math)) + +(sort Fn (UnstableFn (i64) Math)) +(unstable-fn "Inc") diff --git a/tests/fail-typecheck/unstable-fn-wrong-args.egg b/tests/fail-typecheck/unstable-fn-wrong-args.egg new file mode 100644 index 0000000..52ec6c3 --- /dev/null +++ b/tests/fail-typecheck/unstable-fn-wrong-args.egg @@ -0,0 +1,8 @@ +;; test that applying a function with the wrong number of args will violate the type checker + + +(datatype Math + (Inc Math)) + +(sort Fn (UnstableFn (Math) Math)) +(unstable-app (unstable-fn "Inc") 10) diff --git a/tests/fail-typecheck/unstable-fn-wrong-return-type.egg b/tests/fail-typecheck/unstable-fn-wrong-return-type.egg new file mode 100644 index 0000000..be7e242 --- /dev/null +++ b/tests/fail-typecheck/unstable-fn-wrong-return-type.egg @@ -0,0 +1,8 @@ +;; test that you can't resolve a function with the wrong return type + +(datatype Math + (Zero) + (Inc Math)) + +(sort Fn (UnstableFn (Math) i64)) +(unstable-fn "Inc") diff --git a/tests/fail-typecheck/unstable-fn-wrong-return.egg b/tests/fail-typecheck/unstable-fn-wrong-return.egg new file mode 100644 index 0000000..9abe516 --- /dev/null +++ b/tests/fail-typecheck/unstable-fn-wrong-return.egg @@ -0,0 +1,11 @@ +;; test that the value of a applied function is well typed + + +(datatype Math + (Zero) + (Inc Math)) + +(sort Fn (UnstableFn (Math) Math)) +(let x (unstable-app (unstable-fn "Inc") (Zero))) + +(+ x 10) diff --git a/tests/fail_wrong_assertion.egg b/tests/fail_wrong_assertion.egg new file mode 100644 index 0000000..ccabd0f --- /dev/null +++ b/tests/fail_wrong_assertion.egg @@ -0,0 +1,24 @@ +;; This test ensure check test fails for wrong assertion +(function f (i64) i64 :merge (min old new)) + +(set (f 1) 4) +(set (f 1) 5) + +(check (= (f 1) 4)) +(fail (check (= (f 1) 2))) + +(delete (f 1)) +(fail (check (= (f 1) 4))) + +(function g (i64 i64) i64 :merge (min old new)) + +(set (g 1 2) 3) +(set (g 2 3) 3) + +(check (= (g 1 2) (g 2 3))) +(fail (check (!= (g 1 2) (g 2 3)))) +(fail (check (= (g 0 2) (g 2 3)))) +(check (= x (g 1 2))) +(fail (check (= x (g 1 3)))) +(check (= x (g 1 2)) (= y (g 2 3)) (= x y)) +(fail (check (= x (g 0 0)) (= y (g 1 1)) (= x y))) \ No newline at end of file diff --git a/tests/fibonacci-demand.egg b/tests/fibonacci-demand.egg new file mode 100644 index 0000000..22d13f0 --- /dev/null +++ b/tests/fibonacci-demand.egg @@ -0,0 +1,19 @@ +(datatype Expr + (Num i64 :cost 1) + (Add Expr Expr :cost 5)) + +(function Fib (i64) Expr :cost 10) + +(rewrite (Add (Num a) (Num b)) (Num (+ a b))) +(rewrite (Fib x) (Add (Fib (- x 1)) (Fib (- x 2))) + :when ((> x 1))) +(rewrite (Fib x) (Num x) + :when ((<= x 1))) + +(let f7 (Fib 7)) +(run 1000) +(print-function Fib 10) +(extract f7) +(check (= f7 (Num 13))) + + \ No newline at end of file diff --git a/tests/fibonacci.egg b/tests/fibonacci.egg new file mode 100644 index 0000000..89733f8 --- /dev/null +++ b/tests/fibonacci.egg @@ -0,0 +1,11 @@ +(function fib (i64) i64) +(set (fib 0) 0) +(set (fib 1) 1) + +(rule ((= f0 (fib x)) + (= f1 (fib (+ x 1)))) + ((set (fib (+ x 2)) (+ f0 f1)))) + +(run 7) + +(check (= (fib 7) 13)) \ No newline at end of file diff --git a/tests/files.rs b/tests/files.rs new file mode 100644 index 0000000..364c682 --- /dev/null +++ b/tests/files.rs @@ -0,0 +1,131 @@ +use std::path::PathBuf; + +use egglog::*; +use libtest_mimic::Trial; + +#[derive(Clone)] +struct Run { + path: PathBuf, + resugar: bool, +} + +impl Run { + fn run(&self) { + let program = std::fs::read_to_string(&self.path) + .unwrap_or_else(|err| panic!("Couldn't read {:?}: {:?}", self.path, err)); + + if !self.resugar { + self.test_program( + self.path.to_str().map(String::from), + &program, + "Top level error", + ); + } else { + let mut egraph = EGraph::default(); + egraph.run_mode = RunMode::ShowDesugaredEgglog; + egraph.set_reserved_symbol("__".into()); + let desugared_str = egraph + .parse_and_run_program(self.path.to_str().map(String::from), &program) + .unwrap() + .join("\n"); + + self.test_program( + None, + &desugared_str, + "ERROR after parse, to_string, and parse again.", + ); + } + } + + fn test_program(&self, filename: Option, program: &str, message: &str) { + let mut egraph = EGraph::default(); + egraph.set_reserved_symbol("___".into()); + match egraph.parse_and_run_program(filename, program) { + Ok(msgs) => { + if self.should_fail() { + panic!( + "Program should have failed! Instead, logged:\n {}", + msgs.join("\n") + ); + } else { + for msg in msgs { + println!(" {}", msg); + } + // Test graphviz dot generation + let mut serialized = egraph.serialize(SerializeConfig { + max_functions: Some(40), + max_calls_per_function: Some(40), + ..Default::default() + }); + serialized.to_dot(); + // Also try splitting and inlining + serialized.split_classes(|id, _| egraph.from_node_id(id).is_primitive()); + serialized.inline_leaves(); + serialized.to_dot(); + } + } + Err(err) => { + if !self.should_fail() { + panic!("{}: {err}", message) + } + } + }; + } + + fn into_trial(self) -> Trial { + let name = self.name().to_string(); + Trial::test(name, move || { + self.run(); + Ok(()) + }) + } + + fn name(&self) -> impl std::fmt::Display + '_ { + struct Wrapper<'a>(&'a Run); + impl std::fmt::Display for Wrapper<'_> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let stem = self.0.path.file_stem().unwrap(); + let stem_str = stem.to_string_lossy().replace(['.', '-', ' '], "_"); + write!(f, "{stem_str}")?; + if self.0.resugar { + write!(f, "_resugar")?; + } + Ok(()) + } + } + Wrapper(self) + } + + fn should_fail(&self) -> bool { + self.path.to_string_lossy().contains("fail-typecheck") + } +} + +fn generate_tests(glob: &str) -> Vec { + let mut trials = vec![]; + let mut push_trial = |run: Run| trials.push(run.into_trial()); + + for entry in glob::glob(glob).unwrap() { + let run = Run { + path: entry.unwrap().clone(), + resugar: false, + }; + let should_fail = run.should_fail(); + + push_trial(run.clone()); + if !should_fail { + push_trial(Run { + resugar: true, + ..run.clone() + }); + } + } + + trials +} + +fn main() { + let args = libtest_mimic::Arguments::from_args(); + let tests = generate_tests("tests/**/*.egg"); + libtest_mimic::run(&args, tests).exit(); +} diff --git a/tests/fusion.egg b/tests/fusion.egg new file mode 100644 index 0000000..4aa853a --- /dev/null +++ b/tests/fusion.egg @@ -0,0 +1,152 @@ +(datatype Var) +(datatype Term + (App Term Term) + (Lam Var Term) + (TVar Var) + (Let Var Term Term) + (Add Term Term) + (Num i64) + (CaseSplit Term Term Term) + (Cons Term Term)) +(function NilConst () Term) +(let Nil (NilConst)) + +(function V (String) Var) +(function From (Term) Var) + +;; ==== FV ==== +(sort StringSet (Set Var)) +(function freer (Term) StringSet :merge (set-intersect old new)) +(rule ((= e (App e1 e2)) + (= (freer e1) fv1) + (= (freer e2) fv2)) + ((set (freer e) (set-union fv1 fv2)))) +(rule ((= e (Lam var body)) + (= (freer body) fv)) + ((set (freer e) (set-remove fv var)))) +(rule ((= e (TVar v))) + ((set (freer e) (set-insert (set-empty) v)))) +(rule ((= e (Let var e1 e2)) + (= (freer e1) fv1) + (= (freer e2) fv2)) + ((set (freer e) (set-union fv1 (set-remove fv2 var))))) +(rule ((= e (Add e1 e2)) + (= (freer e1) fv1) + (= (freer e2) fv2)) + ((set (freer e) (set-union fv1 fv2)))) +(rule ((= e (Num v))) + ((set (freer e) (set-empty)))) +(rule ((= e (CaseSplit e1 e2 e3)) + (= (freer e1) fv1) + (= (freer e2) fv2) + (= (freer e3) fv3)) + ((set (freer e) (set-union (set-union fv1 fv2) fv3)))) +(rule ((= e (Cons e1 e2)) + (= (freer e1) fv1) + (= (freer e2) fv2)) + ((set (freer e) (set-union fv1 fv2)))) +(rule ((= e Nil)) + ((set (freer e) (set-empty)))) + +;; ==== eval ==== +; beta +(rewrite (App (Lam v body) e) (Let v e body)) +; case-split-nil +(rewrite (CaseSplit Nil e1 e2) e1) +; case-split-cons +(rewrite (CaseSplit (Cons x xs) e1 e2) (App (App e2 x) xs)) + +; let-num +(rewrite (Let v e (Num n)) (Num n)) +; let-nil +(rewrite (Let v e Nil) Nil) +; let-var-same +(rewrite (Let v1 e (TVar v1)) e) +; let-var-diff +(rewrite (Let v1 e (TVar v2)) (TVar v2) :when ((!= v1 v2))) + +; let-lam-close +(rewrite (Let v1 e expr) expr :when ((set-not-contains (freer expr) v1))) +; let-app +(rewrite (Let v e expr) (App (Let v e a) (Let v e b)) :when ((= expr (App a b)) (set-contains (freer expr) v))) +; let-add +(rewrite (Let v e expr) (Add (Let v e a) (Let v e b)) :when ((= expr (Add a b)) (set-contains (freer expr) v))) +; let-cons +(rewrite (Let v e expr) (Cons (Let v e x) (Let v e xs)) :when ((= expr (Cons x xs)) (set-contains (freer expr) v))) +; let-case-split +(rewrite (Let v e expr) + (CaseSplit (Let v e e1) (Let v e e2) (Let v e e3)) + :when ((= expr (CaseSplit e1 e2 e3)) + (set-contains (freer expr) v))) +; let-lam-same +(rewrite (Let v1 e (Lam v1 body)) (Lam v1 body)) +; let-lam-diff +(rewrite (Let v1 e (Lam v2 body)) (Lam v2 (Let v1 e body)) + :when ((set-contains (freer body) v1) + (!= v1 v2) + (= fvs (freer e)) + (set-not-contains fvs v2))) +(rule ((= expr (Let v1 e (Lam v2 body))) + (set-contains (freer body) v1) + (!= v1 v2) + (= fvs (freer e)) + (set-contains fvs v2)) + ((union expr (Lam (From expr) (Let v1 e (Let v2 (TVar (From expr)) body)))))) + +(function pushdown (Term Term) Term :cost 10000) +(rewrite (App f (App (Lam x e) e2)) + (App (Lam x (pushdown f e)) e2)) + +(rewrite (pushdown f (CaseSplit e e1 (Lam x (Lam xs e2)))) + (CaseSplit e (App f e1) (Lam x (Lam xs (App f e2))))) + +(relation is-tail (Term)) +(rule ((= demand (pushdown f e)) (= e (App e1 e2))) ((is-tail e))) +(rule ((= demand (pushdown f e)) (= e (Lam x e))) ((is-tail e))) +(rule ((= demand (pushdown f e)) (= e (TVar x))) ((is-tail e))) +(rule ((= demand (pushdown f e)) (= e (Cons e1 e2))) ((is-tail e))) +(rule ((= demand (pushdown f e)) (= e Nil)) ((is-tail e))) +(rule ((= demand (pushdown f e)) (= e (Add e1 e2))) ((is-tail e))) +(rule ((= demand (pushdown f e)) (= e (Num n1))) ((is-tail e))) +(rewrite (pushdown f e) (App f e) :when ((is-tail e))) + +;; ==== definition ==== + +(function sum () Term :cost 1000) +(function mapf () Term :cost 1000) +(function sum-o-mapf () Term) +(rewrite (App (sum) (App (mapf) x)) (App (sum-o-mapf) x)) +(union (sum) (Lam (V "xs") + (CaseSplit (TVar (V "xs")) + (Num 0) + (Lam (V "x") (Lam (V "xs'") + (Add (TVar (V "x")) (App (sum) (TVar (V "xs'"))))))))) + +(union (mapf) (Lam (V "xs") + (CaseSplit (TVar (V "xs")) + Nil + (Lam (V "x") (Lam (V "xs'") + (Cons (Add (TVar (V "x")) (Num 1)) + (App (mapf) (TVar (V "xs'"))))))))) + +(set (freer (sum)) (set-empty)) +(set (freer (mapf)) (set-empty)) + +(let expr (App (sum) (App (mapf) (TVar (V "expr"))))) + +(run 100) + +(query-extract (freer expr)) + + +(let my-output + (CaseSplit (TVar (V "expr")) (Num 0) + (Lam (V "x") (Lam (V "xs'") + (Add (Add (TVar (V "x")) (Num 1)) + (App (sum-o-mapf) (TVar (V "xs'")))))))) + +(check (= (App (sum-o-mapf) (TVar (V "expr"))) + (CaseSplit (TVar (V "expr")) (Num 0) + (Lam (V "x") (Lam (V "xs'") + (Add (Add (TVar (V "x")) (Num 1)) + (App (sum-o-mapf) (TVar (V "xs'"))))))))) diff --git a/tests/herbie-tutorial.egg b/tests/herbie-tutorial.egg new file mode 100644 index 0000000..2c2b8db --- /dev/null +++ b/tests/herbie-tutorial.egg @@ -0,0 +1,137 @@ +(datatype Math + (Num Rational) + (Var String) + (Add Math Math) + (Div Math Math) + (Mul Math Math)) + +(let zero (Num (rational 0 1))) +(let one (Num (rational 1 1))) +(let two (Num (rational 2 1))) + +(rewrite (Add a b) (Add b a)) +(rewrite (Add a zero) a) +(rewrite (Add (Num r1) (Num r2)) + (Num (+ r1 r2))) + +(let one-two (Add one two)) + +(push) +(run 1) +;; yay, constant folding works +(check (= one-two (Num (rational 3 1)))) +;; also, commutativity works +(check (= (Add two one) one-two)) +(pop) + +(push) +;; rule is like rewrite, but more general +;; the following rule doesn't union (Num r) with the result: +(rule ((Num r)) + ((union one (Div (Num r) (Num r))))) +;; uh oh, division by zero! +(run 1) + +(pop) + +;; we need to detect when things are non-zero +(function lower-bound (Math) Rational :merge (max old new)) +(function upper-bound (Math) Rational :merge (min old new)) + +(rule ((Num r)) + ((set (lower-bound (Num r)) r) + (set (upper-bound (Num r)) r))) +(rule ((= e (Add a b)) (= x (lower-bound a)) (= y (lower-bound b))) + ((set (lower-bound e) (+ x y)))) +(rule ((= e (Add a b)) (= x (upper-bound a)) (= y (upper-bound b))) + ((set (upper-bound e) (+ x y)))) +(rule ((= e (Mul a b))) + ((set (lower-bound e) + (min (* (lower-bound a) (lower-bound b)) + (min (* (lower-bound a) (upper-bound b)) + (min (* (upper-bound a) (lower-bound b)) + (* (upper-bound a) (upper-bound b)))))) + (set (upper-bound e) + (max (* (lower-bound a) (lower-bound b)) + (max (* (lower-bound a) (upper-bound b)) + (max (* (upper-bound a) (lower-bound b)) + (* (upper-bound a) (upper-bound b)))))))) + +(rule ((= e (Add a b)) + (> (lower-bound e) (rational 0 1))) + ((union one (Div (Add a b) (Add a b))))) + +(let x (Var "x")) +(let x1 (Add x one)) + +(push) +(set (lower-bound x) (rational 0 1)) +(set (upper-bound x) (rational 1 1)) + +(run 3) + +(query-extract (lower-bound x1)) +(query-extract (upper-bound x1)) +(check (= one (Div x1 x1))) + +(pop) + + +;; Set the variable x to a particular input value 200/201 +(set (lower-bound x) (rational 200 201)) +(set (upper-bound x) (rational 200 201)) + +(run 3) + +(query-extract (lower-bound x1)) +(query-extract (upper-bound x1)) + +(function true-value (Math) f64) + +(rule ((= (to-f64 (lower-bound e)) + (to-f64 (upper-bound e)))) + ((set (true-value e) + (to-f64 (lower-bound e))))) + +(run 1) +(query-extract (true-value x1)) + +(function best-error (Math) f64 :merge new :default (to-f64 (rational 10000 1))) + +(rule ((Num n)) + ((set (best-error (Num n)) (to-f64 n)))) +(rule ((Add a b)) ((best-error (Add a b)))) + +;; finally, the mega rule for finding more accurate programs +(rule ((= expr (Add a b)) + (= (best-error a) va) + (= (best-error b) vb) + (= true-v (true-value (Add a b))) + (= computed (+ va vb)) + (< (abs (- computed true-v)) + (best-error (Add a b)))) + ((set (best-error (Add a b)) computed))) + + + +(push) + +(let target + (Add + (Add (Num (rational 1 100)) (Num (rational 1 100))) + (Num (rational -2 100)))) + +(run 1) + +;; set a default +(best-error target) +;; error is bad, constant folding hasn't fired enough +(query-extract (best-error target)) + +(run 1) + +;; error is good, constant folding has fired enough +(query-extract (best-error target)) + + +(pop) \ No newline at end of file diff --git a/tests/herbie.egg b/tests/herbie.egg new file mode 100644 index 0000000..6b19c31 --- /dev/null +++ b/tests/herbie.egg @@ -0,0 +1,570 @@ +;; Implements part of the simplification layer of herbie in egglog🫡 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Datatypes + +(datatype Math + ; Ground terms + (Num Rational) + (Var String) + + ; Custom ops + (Const String) + (Unary String Math) + ; unneeded for now + ; (Binary String Math Math) + + ; Constant-folding ops + (Add Math Math) + (Sub Math Math) + (Mul Math Math) + (Div Math Math) + (Pow Math Math) + (Neg Math) + (Sqrt Math) + (Cbrt Math) ; cube root + (Fabs Math) + (Ceil Math) + (Floor Math) + (Round Math) + (Log Math)) + +(let r-zero (rational 0 1)) +(let r-one (rational 1 1)) +(let r-two (rational 2 1)) +(let zero (Num r-zero)) +(let one (Num r-one)) +(let two (Num r-two)) +(let three (Num (rational 3 1))) +(let neg-one (Neg one)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Analyses +;; -------- +;; This example has three analyses: +;; an interval analysis consisting of a hi and lo component +;; and a non-zero analysis. +;; The non-zero analysis is built off the interval analysis (in order to prove +;; that rewrites are sound, even if some parts of an expr can't be const-evaled) + +; TODO: unbounded intervals? +(function hi (Math) Rational :merge (min old new)) +(function lo (Math) Rational :merge (max old new)) +(relation non-zero (Math)) + +;; First, constant folding! +;; We don't need an explicit constant folding analysis, we can just union +;; with nums when we can + +; Cases +(rewrite (Add (Num a) (Num b)) (Num (+ a b))) +(rewrite (Sub (Num a) (Num b)) (Num (- a b))) +(rewrite (Mul (Num a) (Num b)) (Num (* a b))) +(rewrite (Div (Num a) denom) (Num (/ a b)) :when ((= denom (Num b)) (non-zero denom))) +(rewrite (Pow (Num a) (Num b)) (Num res) :when ((= res (pow a b)))) +(rewrite (Neg (Num a)) (Num (neg a))) +;; TODO unimplemented +;; (rewrite (Sqrt (Num a)) (Num res) :when ((= res (sqrt a)))) +;; (rewrite (Cbrt (Num a)) (Num res) :when ((= res (cbrt a)))) +(rewrite (Fabs (Num a)) (Num (abs a))) +(rewrite (Ceil (Num a)) (Num (ceil a))) +(rewrite (Floor (Num a)) (Num (floor a))) +(rewrite (Round (Num a)) (Num (round a))) +(rewrite (Log (Num a)) (Num res) :when ((= res (log a)))) + +;; To check if something is zero, we check that zero is not contained in the +;; interval. There are two possible (overlapping!) cases: +;; - There exists a lo interval, in which case it must be larger than 0 +;; - There exists a hi interval, in which case it must be smaller than 0 +;; This assumes that intervals are well-formed: lo <= hi at all times. +(rule ((= l (lo e)) + (> l r-zero)) + ((non-zero e))) +(rule ((= h (hi e)) + (< h r-zero)) + ((non-zero e))) + +(rule ((= e (Num ve))) + ((set (lo e) ve) + (set (hi e) ve))) + +;; The interval analyses are similar to the constant-folding analysis, +;; except we have to take the lower/upper bound of the results we get +(rule ((= e (Add a b)) + (= la (lo a)) + (= lb (lo b))) + ((set (lo e) (+ la lb)))) +(rule ((= e (Add a b)) + (= ha (hi a)) + (= hb (hi b))) + ((set (hi e) (+ ha hb)))) + +(rule ((= e (Sub a b)) + (= la (lo a)) + (= ha (hi a)) + (= lb (lo b)) + (= hb (hi b))) + ((set (lo e) + (min (min (- la lb) (- la hb)) + (min (- ha lb) (- ha hb)))) + (set (hi e) + (max (max (- la lb) (- la hb)) + (max (- ha lb) (- ha hb)))))) + +(rule ((= e (Mul a b)) + (= la (lo a)) + (= ha (hi a)) + (= lb (lo b)) + (= hb (hi b))) + ((set (lo e) + (min (min (* la lb) (* la hb)) + (min (* ha lb) (* ha hb)))) + (set (hi e) + (max (max (* la lb) (* la hb)) + (max (* ha lb) (* ha hb)))))) + +(rule ((= e (Div a b)) + (= la (lo a)) + (= ha (hi a)) + (= lb (lo b)) + (= hb (hi b))) + ((set (lo e) + (min (min (/ la lb) (/ la hb)) + (min (/ ha lb) (/ ha hb)))) + (set (hi e) + (max (max (/ la lb) (/ la hb)) + (max (/ ha lb) (/ ha hb)))))) + +; TODO: Pow + +(rule ((= e (Neg a)) + (= la (lo a)) + (= ha (hi a))) + ((set (lo e) (neg ha)) + (set (hi e) (neg la)))) + +; TODO: Sqrt +; TODO: Cbrt + +(rule ((= e (Fabs a)) + (= la (lo a)) + (= ha (hi a))) + ((set (lo e) (min (abs la) (abs ha))) + (set (hi e) (max (abs la) (abs ha))))) + +(rule ((= e (Ceil a)) + (= la (lo a))) + ((set (lo e) (ceil la)))) +(rule ((= e (Ceil a)) + (= ha (hi a))) + ((set (hi e) (ceil ha)))) + +(rule ((= e (Floor a)) + (= la (lo a))) + ((set (lo e) (floor la)))) +(rule ((= e (Floor a)) + (= ha (hi a))) + ((set (hi e) (floor ha)))) + +(rule ((= e (Round a)) + (= la (lo a))) + ((set (lo e) (round la)))) +(rule ((= e (Round a)) + (= ha (hi a))) + ((set (hi e) (round ha)))) + +; TODO: Log + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Rewrites +;; -------- +;; These rewrites were compiled from src/syntax/rules.rkt in the herbie repo, +;; using all rewrites in the `simplify` rewrite group. + +;; Commutativity +(rewrite (Add a b) (Add b a)) +(rewrite (Mul a b) (Mul b a)) + +;; Associativity +(rewrite (Add a (Add b c)) (Add (Add a b) c)) +(rewrite (Add (Add a b) c) (Add a (Add b c))) +(rewrite (Add a (Sub b c)) (Sub (Add a b) c)) +(rewrite (Add (Sub a b) c) (Sub a (Sub b c))) +(rewrite (Sub a (Add b c)) (Sub (Sub a b) c)) +(rewrite (Sub (Add a b) c) (Add a (Sub b c))) +(rewrite (Sub (Sub a b) c) (Sub a (Add b c))) +(rewrite (Sub a (Sub b c)) (Add (Sub a b) c)) +(rewrite (Mul a (Mul b c)) (Mul (Mul a b) c)) +(rewrite (Mul (Mul a b) c) (Mul a (Mul b c))) +(rewrite (Mul a (Div b c)) (Div (Mul a b) c)) +(rewrite (Mul (Div a b) c) (Div (Mul a c) b)) +(rewrite (Div a (Mul b c)) (Div (Div a b) c)) +(rewrite (Div (Mul b c) a) (Div b (Div a c)) :when ((non-zero c))) +(rewrite (Div a (Div b c)) (Mul (Div a b) c) :when ((non-zero c))) +(rewrite (Div (Div b c) a) (Div b (Mul a c)) :when ((non-zero a))) + +;; Counting +(rewrite (Add x x) (Mul two x)) + +;; Distributivity +(rewrite (Mul a (Add b c)) (Add (Mul a b) (Mul a c))) +(rewrite (Mul a (Add b c)) (Add (Mul b a) (Mul c a))) +(rewrite (Add (Mul a b) (Mul a c)) (Mul a (Add b c))) +(rewrite (Sub (Mul a b) (Mul a c)) (Mul a (Sub b c))) +(rewrite (Add (Mul b a) (Mul c a)) (Mul a (Add b c))) +(rewrite (Sub (Mul b a) (Mul c a)) (Mul a (Sub b c))) +(rewrite (Add (Mul b a) a) (Mul (Add b one) a)) +(rewrite (Add a (Mul c a)) (Mul (Add c one) a)) + +(rewrite (Neg (Mul a b)) (Mul (Neg a) b)) +(rewrite (Neg (Mul a b)) (Mul a (Neg b))) +(rewrite (Mul (Neg a) b) (Neg (Mul a b))) +(rewrite (Mul a (Neg b)) (Neg (Mul a b))) +(rewrite (Neg (Add a b)) (Add (Neg a) (Neg b))) +(rewrite (Add (Neg a) (Neg b)) (Neg (Add a b))) +(rewrite (Div (Neg a) b) (Neg (Div a b))) +(rewrite (Neg (Div a b)) (Div (Neg a) b)) + +(rewrite (Sub a (Mul (Neg b) c)) (Add a (Mul b c))) +(rewrite (Sub a (Mul b c)) (Add a (Mul (Neg b) c))) + +;; Difference of squares +(rewrite (Mul (Mul a b) (Mul a b)) (Mul (Mul a a) (Mul b b))) +(rewrite (Mul (Mul a a) (Mul b b)) (Mul (Mul a b) (Mul a b))) +(rewrite (Sub (Mul a a) (Mul b b)) (Mul (Add a b) (Sub a b))) +(rewrite (Sub (Mul a a) one) (Mul (Add a one) (Sub a one))) +(rewrite (Add (Mul a a) (Neg one)) (Mul (Add a one) (Sub a one))) +(rewrite (Pow a b) (Mul (Pow a (Div b two)) (Pow a (Div b two)))) +(rewrite (Mul (Pow a b) (Pow a b)) (Pow a (Mul two b))) + +;; Identity +;; This isn't subsumed by const folding since this can return results +;; even if we can't evaluate a precise value for x +(rewrite (Div one (Div one x)) + x + :when ((non-zero x))) +(rewrite (Mul x (Div one x)) + one + :when ((non-zero x))) +(rewrite (Mul (Div one x) x) + one + :when ((non-zero x))) + +(rewrite (Sub x x) zero) +(rewrite (Div x x) one + :when ((non-zero x))) +(rewrite (Div zero x) zero + :when ((non-zero x))) +(rewrite (Mul zero x) zero) +(rewrite (Mul x zero) zero) + +(rewrite (Add zero x) x) +(rewrite (Add x zero) x) +(rewrite (Sub zero x) (Neg x)) +(rewrite (Sub x zero) x) +(rewrite (Neg (Neg x)) x) +(rewrite (Mul one x) x) +(rewrite (Mul x one) x) +(rewrite (Div x one) x) +(rewrite (Mul neg-one x) (Neg x)) + +(rewrite (Sub a b) (Add a (Neg b))) +(rewrite (Add a (Neg b)) (Sub a b)) +(rewrite (Neg x) (Sub zero x)) +(rewrite (Neg x) (Mul neg-one x)) + +(rewrite (Div x y) (Mul x (Div one y))) +(rewrite (Mul x (Div one y)) (Div x y)) +(rewrite (Div x y) (Div one (Div y x)) + :when ((non-zero x) + (non-zero y))) + +; FIXME: this rule can't be expressed in its full generality; +; we can't express the general rule x -> 1/x since +; we can't quantify over Math yet +; for now we just apply it to vars +; it's also p slow lmao +(rewrite (Var x) (Mul one (Var x))) + +;; Fractions +(rewrite (Div (Sub a b) c) (Sub (Div a c) (Div b c))) +(rewrite (Div (Mul a b) (Mul c d)) (Mul (Div a c) (Div b d))) + +;; Square root +(rewrite (Mul (Sqrt x) (Sqrt x)) x) +(rewrite (Sqrt (Mul x x)) (Fabs x)) + +(rewrite (Mul (Neg x) (Neg x)) (Mul x x)) +(rewrite (Mul (Fabs x) (Fabs x)) (Mul x x)) + +;; Absolute values +(rewrite (Fabs (Fabs x)) (Fabs x)) +(rewrite (Fabs (Sub a b)) (Fabs (Sub b a))) +(rewrite (Fabs (Neg x)) (Fabs x)) +(rewrite (Fabs (Mul x x)) (Mul x x)) +(rewrite (Fabs (Mul a b)) (Mul (Fabs a) (Fabs b))) +(rewrite (Fabs (Div a b)) (Div (Fabs a) (Fabs b))) + +;; Cube root +(rewrite (Pow (Cbrt x) three) x) +(rewrite (Cbrt (Pow x three)) x) +(rewrite (Mul (Mul (Cbrt x) (Cbrt x)) (Cbrt x)) x) +(rewrite (Mul (Cbrt x) (Mul (Cbrt x) (Cbrt x))) x) +(rewrite (Pow (Neg x) three) (Neg (Pow x three))) + +(rewrite (Pow (Mul x y) three) + (Mul (Pow x three) (Pow y three))) +(rewrite (Pow (Div x y) three) + (Div (Pow x three) (Pow y three))) + +(rewrite (Pow x three) (Mul x (Mul x x))) +; FIXME: this rewrite is slow and has the potential to blow up the egraph +; this is bc this rule and the second-to-last difference of squares rule +; have some cyclic behavior goin on +; the last identity rule compounds this behavior +(rewrite (Mul x (Mul x x)) (Pow x three)) + +;; Exponentials +(rewrite (Unary "exp" (Log x)) x) +(rewrite (Log (Unary "exp" x)) x) + +(rewrite (Unary "exp" zero) one) +(rewrite (Unary "exp" one) (Const "E")) +;; (rewrite one (Unary "exp" zero)) +(rewrite (Const "E") (Unary "exp" one)) + +(rewrite (Unary "exp" (Add a b)) (Mul (Unary "exp" a) (Unary "exp" b))) +(rewrite (Unary "exp" (Sub a b)) (Div (Unary "exp" a) (Unary "exp" b))) +(rewrite (Unary "exp" (Neg a)) (Div one (Unary "exp" a))) + +(rewrite (Mul (Unary "exp" a) (Unary "exp" b)) (Unary "exp" (Add a b))) +(rewrite (Div one (Unary "exp" a)) (Unary "exp" (Neg a))) +(rewrite (Div (Unary "exp" a) (Unary "exp" b)) (Unary "exp" (Sub a b))) +(rewrite (Unary "exp" (Mul a b)) (Pow (Unary "exp" a) b)) +(rewrite (Unary "exp" (Div a two)) (Sqrt (Unary "exp" a))) +(rewrite (Unary "exp" (Div a three)) (Cbrt (Unary "exp" a))) +(rewrite (Unary "exp" (Mul a two)) (Mul (Unary "exp" a) (Unary "exp" a))) +(rewrite (Unary "exp" (Mul a three)) (Pow (Unary "exp" a) three)) + +;; Powers +(rewrite (Pow a neg-one) (Div one a)) +(rewrite (Pow a one) a) + +; 0^0 is undefined +(rewrite (Pow a zero) one :when ((non-zero a))) +(rewrite (Pow one a) one) + +(rewrite (Unary "Exp" (Mul (Log a) b)) (Pow a b)) +(rewrite (Mul (Pow a b) a) (Pow a (Add b one))) +(rewrite (Pow a (Num (rational 1 2))) (Sqrt a)) +(rewrite (Pow a two) (Mul a a)) +(rewrite (Pow a (Num (rational 1 3))) (Cbrt a)) +(rewrite (Pow a three) (Mul (Mul a a) a)) + +; 0^0 is undefined +(rewrite (Pow zero a) zero :when ((non-zero a))) + +;; Logarithms +(rewrite (Log (Mul a b)) (Add (Log a) (Log b))) +(rewrite (Log (Div a b)) (Sub (Log a) (Log b))) +(rewrite (Log (Div one a)) (Neg (Log a))) +(rewrite (Log (Pow a b)) (Mul b (Log a))) +(rewrite (Log (Const "E")) one) + +;; Trigonometry +(rewrite (Add (Mul (Unary "cos" a) (Unary "cos" a)) (Mul (Unary "sin" a) (Unary "sin" a))) + one) +(rewrite (Sub one (Mul (Unary "cos" a) (Unary "cos" a))) + (Mul (Unary "sin" a) (Unary "sin" a))) +(rewrite (Sub one (Mul (Unary "sin" a) (Unary "sin" a))) + (Mul (Unary "cos" a) (Unary "cos" a))) +(rewrite (Add (Mul (Unary "cos" a) (Unary "cos" a)) (Num (rational -1 1))) + (Neg (Mul (Unary "sin" a) (Unary "sin" a)))) +(rewrite (Add (Mul (Unary "sin" a) (Unary "sin" a)) (Num (rational -1 1))) + (Neg (Mul (Unary "cos" a) (Unary "cos" a)))) +(rewrite (Sub (Mul (Unary "cos" a) (Unary "cos" a)) one) + (Neg (Mul (Unary "sin" a) (Unary "sin" a)))) +(rewrite (Sub (Mul (Unary "sin" a) (Unary "sin" a)) one) + (Neg (Mul (Unary "cos" a) (Unary "cos" a)))) +(rewrite (Unary "sin" (Div (Const "PI") (Num (rational 6 1)))) + (Num (rational 1 2))) +(rewrite (Unary "sin" (Div (Const "PI") (Num (rational 4 1)))) + (Div (Sqrt two) two)) +(rewrite (Unary "sin" (Div (Const "PI") three)) + (Div (Sqrt three) two)) +(rewrite (Unary "sin" (Div (Const "PI") two)) + one) +(rewrite (Unary "sin" (Const "PI")) + zero) +(rewrite (Unary "sin" (Add x (Const "PI"))) + (Neg (Unary "sin" x))) +(rewrite (Unary "sin" (Add x (Div (Const "PI") two))) + (Unary "cos" x)) +(rewrite (Unary "cos" (Div (Const "PI") (Num (rational 6 1)))) + (Div (Sqrt three) two)) +(rewrite (Unary "cos" (Div (Const "PI") (Num (rational 4 1)))) + (Div (Sqrt two) two)) +(rewrite (Unary "cos" (Div (Const "PI") three)) + (Num (rational 1 2))) +(rewrite (Unary "cos" (Div (Const "PI") two)) + zero) +(rewrite (Unary "cos" (Const "PI")) + (Num (rational -1 1))) +(rewrite (Unary "cos" (Add x (Const "PI"))) + (Neg (Unary "cos" x))) +(rewrite (Unary "cos" (Add x (Div (Const "PI") two))) + (Neg (Unary "sin" x))) +(rewrite (Unary "tan" (Div (Const "PI") (Num (rational 6 1)))) + (Div one (Sqrt three))) +(rewrite (Unary "tan" (Div (Const "PI") (Num (rational 4 1)))) + one) +(rewrite (Unary "tan" (Div (Const "PI") three)) + (Sqrt three)) +(rewrite (Unary "tan" (Const "PI")) + zero) +(rewrite (Unary "tan" (Add x (Const "PI"))) + (Unary "tan" x)) +(rewrite (Unary "tan" (Add x (Div (Const "PI") two))) + (Div neg-one (Unary "tan" x))) +(rewrite (Div (Unary "sin" a) (Add one (Unary "cos" a))) + (Unary "tan" (Div a two))) +(rewrite (Div (Neg (Unary "sin" a)) (Add one (Unary "cos" a))) + (Unary "tan" (Div (Neg a) two))) +(rewrite (Div (Sub one (Unary "cos" a)) (Unary "sin" a)) + (Unary "tan" (Div a two))) +(rewrite (Div (Sub one (Unary "cos" a)) (Neg (Unary "sin" a))) + (Unary "tan" (Div (Neg a) two))) +(rewrite (Div (Add (Unary "sin" a) (Unary "sin" b)) (Add (Unary "cos" a) (Unary "cos" b))) + (Unary "tan" (Div (Add a b) two))) +(rewrite (Div (Sub (Unary "sin" a) (Unary "sin" b)) (Add (Unary "cos" a) (Unary "cos" b))) + (Unary "tan" (Div (Sub a b) two))) + +(rewrite (Unary "sin" zero) zero) +(rewrite (Unary "cos" zero) one) +(rewrite (Unary "tan" zero) zero) + +(rewrite (Unary "sin" (Neg x)) (Neg (Unary "sin" x))) +(rewrite (Unary "cos" (Neg x)) (Unary "cos" x)) +(rewrite (Unary "tan" (Neg x)) (Neg (Unary "cos" x))) + +; Hyperbolics +(rewrite (Unary "sinh" x) (Div (Sub (Unary "exp" x) (Unary "exp" (Neg x))) two)) +(rewrite (Unary "cosh" x) (Div (Add (Unary "exp" x) (Unary "exp" (Neg x))) two)) +(rewrite (Unary "tanh" x) (Div (Sub (Unary "exp" x) (Unary "exp" (Neg x))) (Add (Unary "exp" x) (Unary "exp" (Neg x))))) +(rewrite (Unary "tanh" x) (Div (Sub (Unary "exp" (Mul two x)) one) (Add (Unary "exp" (Mul two x)) one))) +(rewrite (Unary "tanh" x) (Div (Sub one (Unary "exp" (Mul (Num (rational -2 1)) x))) (Add one (Unary "exp" (Mul (Num (rational -2 1)) x))))) +(rewrite (Sub (Mul (Unary "cosh" x) (Unary "cosh" x)) (Mul (Unary "sinh" x) (Unary "sinh" x))) one) +(rewrite (Add (Unary "cosh" x) (Unary "sinh" x)) (Unary "exp" x)) +(rewrite (Sub (Unary "cosh" x) (Unary "sinh" x)) (Unary "exp" (Neg x))) + +;; Unimplemented: misc. rewrites (conditionals, specialized numerical fns) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Testing +;; ------- +;; In actuality, herbie would be responsible for plugging exprs in here. +;; For our purposes, we take some test cases from herbie +;; (src/core/simplify.rkt) + +(push) +(let e (Add one zero)) +(run 1) +(check (= e one)) +(pop) + +(push) +(let five (Num (rational 5 1))) +(let six (Num (rational 6 1))) +(let e2 (Add one five)) +(run 1) +(check (= e2 six)) +(pop) + +(let x (Var "x")) + +(push) +(let e3 (Add x zero)) +(run 1) +(check (= e3 x)) +(pop) + +(push) +(let e4 (Sub x zero)) +(run 1) +(check (= e4 x)) +(pop) + +(push) + +(let e5 (Mul x one)) +(run 1) +(check (= e5 x)) +(pop) + +(push) + +(let e6 (Div x one)) +(run 1) +(check (= e6 x)) +(pop) + +(push) + +(let e7 (Sub (Mul one x) (Mul (Add x one) one))) +(run 3) +(check (= e7 (Num (rational -1 1)))) +(pop) + +(push) + +(let e8 (Sub (Add x one) x)) +(run 4) +(check (= e8 one)) +(pop) + +(push) + +(let e9 (Sub (Add x one) one)) +(run 4) +(check (= e9 x)) +(pop) + +(push) + +(set (lo x) r-one) +(let e10 (Div (Mul x three) x)) +(run 3) +(check (= e10 three)) +(pop) + +(push) + +(let e11 (Sub (Mul (Sqrt (Add x one)) (Sqrt (Add x one))) (Mul (Sqrt x) (Sqrt x)))) +(run 5) +(check (= one e11)) +(pop) + +(push) +(let e12 (Add (Num (rational 1 5)) (Num (rational 3 10)))) +(run 1) +(check (= e12 (Num (rational 1 2)))) +(pop) + +(push) +(let e13 (Unary "cos" (Const "PI"))) +(run 1) +(check (= e13 (Num (rational -1 1)))) +(pop) + +(push) +(let sqrt5 (Sqrt (Num (rational 5 1)))) +(let e14 + (Div one (Sub (Div (Add one sqrt5) two) (Div (Sub one sqrt5) two)))) +(let tgt (Div one sqrt5)) +(run 6) +(check (= e14 tgt)) +(pop) \ No newline at end of file diff --git a/tests/i64.egg b/tests/i64.egg new file mode 100644 index 0000000..00728eb --- /dev/null +++ b/tests/i64.egg @@ -0,0 +1 @@ +(check (= (to-string 20) "20")) diff --git a/tests/include.egg b/tests/include.egg new file mode 100644 index 0000000..14a6040 --- /dev/null +++ b/tests/include.egg @@ -0,0 +1,2 @@ +(include "tests/path.egg") +(check (path 1 3)) diff --git a/tests/integer_math.egg b/tests/integer_math.egg new file mode 100644 index 0000000..747fc86 --- /dev/null +++ b/tests/integer_math.egg @@ -0,0 +1,106 @@ +(datatype Math + (Diff Math Math) + (Integral Math Math) + + (Add Math Math) + (Sub Math Math) + (Mul Math Math) + (Div Math Math) + (Pow Math Math) + (RShift Math Math) + (LShift Math Math) + (Mod Math Math) + (Not Math) + + (Const i64) + (Var String)) + +(relation MathU (Math)) +(rule ((= e (Diff x y))) ((MathU e))) +(rule ((= e (Integral x y))) ((MathU e))) +(rule ((= e (Add x y))) ((MathU e))) +(rule ((= e (Sub x y))) ((MathU e))) +(rule ((= e (Mul x y))) ((MathU e))) +(rule ((= e (Div x y))) ((MathU e))) +(rule ((= e (Pow x y))) ((MathU e))) +(rule ((= e (Const x))) ((MathU e))) +(rule ((= e (Var x))) ((MathU e))) +(rule ((= e (RShift x y))) ((MathU e))) +(rule ((= e (LShift x y))) ((MathU e))) +(rule ((= e (Mod x y))) ((MathU e))) +(rule ((= e (Not x))) ((MathU e))) + +(relation evals-to (Math i64)) +(rule ((evals-to x vx)) ((union x (Const vx)))) +(rule ((= e (Const c))) ((evals-to e c))) + +(relation is-not-zero (Math)) +(rule ((MathU a) (!= a (Const 0))) ((is-not-zero a))) + +;; Evaluation +(rewrite (Add (Const a) (Const b)) + (Const (+ a b))) +(rewrite (Sub (Const a) (Const b)) + (Const (- a b))) +(rewrite (Mul (Const a) (Const b)) (Const (* a b))) +(rewrite (Div (Const a) (Const b)) (Const (/ a b)) :when ((!= 0 b))) +(rewrite (RShift (Const a) (Const b)) (Const (>> a b))) +(rewrite (LShift (Const a) (Const b)) (Const (<< a b))) +(rewrite (Not (Const a)) (Const (not-i64 a))) + +;; Properties +(rewrite (Add a b) (Add b a)) +(rewrite (Mul a b) (Mul b a)) +(rewrite (Add a (Add b c)) (Add (Add a b) c)) +(rewrite (Mul a (Mul b c)) (Mul (Mul a b) c)) + +(rewrite (Sub a b) (Add a (Mul (Const -1) b))) + +(rewrite (Add a (Const 0)) a) +(rewrite (Mul a (Const 0)) (Const 0)) +(rewrite (Mul a (Const 1)) a) + +(rule ((MathU a) (!= a (Const 0))) ((union a (Add a (Const 0))))) +(rule ((MathU a) (!= a (Const 1))) ((union a (Mul a (Const 1))))) + +(rewrite (Sub a a) (Const 0)) +(rewrite (Div a a) (Const 1) :when ((is-not-zero a))) + +(rewrite (Mul a (Add b c)) (Add (Mul a b) (Mul a c))) +(rewrite (Add (Mul a b) (Mul a c)) (Mul a (Add b c))) + +; This rule doesn't work when pow is negative - consider 2^-1 * 2^1, which is 0, but 2^0 = 1 +(rewrite (Mul (Pow a b) (Pow a c)) (Pow a (Add b c)) :when ((is-not-zero b) (is-not-zero c))) + +(rewrite (Pow x (Const 0)) (Const 1) :when ((is-not-zero x))) +(rewrite (Pow x (Const 1 )) x) +(rewrite (Pow x (Const 2)) (Mul x x)) + +(rewrite (Pow x (Const -1)) (Div (Const 1) x) :when ((is-not-zero x))) + +(rewrite (Mul x (Pow (Const 2) y)) (LShift x y)) +(rewrite (Div x (Pow (Const 2) y)) (RShift x y)) + +(rewrite (Not (Not x)) x) + + +;; Tests +(let start-expr (Div ( + Mul (Var "a") (Pow (Const 2) (Const 3)) + ) ( + Add (Var "c") ( + Sub (Mul (Var "b") (Const 2)) (Mul (Var "b") (Const 2)) + ) + ))) + +(let equiv-expr (Div ( + LShift (Var "a") (Const 3) + ) ( + Mul (Var "c") (Not (Not (Const 1))) + ) + )) + +(run 4) + +(check (= start-expr equiv-expr)) + diff --git a/tests/integration_test.rs b/tests/integration_test.rs new file mode 100644 index 0000000..9418875 --- /dev/null +++ b/tests/integration_test.rs @@ -0,0 +1,441 @@ +use egglog::ast::Symbol; +use egglog::{ast::Expr, EGraph, ExtractReport, Function, SerializeConfig, Term, Value}; + +#[test] +fn test_subsumed_unextractable_action_extract() { + // Test when an expression is subsumed, it isn't extracted, even if its the cheapest + let mut egraph = EGraph::default(); + + egraph + .parse_and_run_program( + None, + r#" + (datatype Math) + (function exp () Math :cost 100) + (function cheap () Math :cost 1) + (union (exp) (cheap)) + (query-extract (exp)) + "#, + ) + .unwrap(); + // Originally should give back numeric term + assert!(matches!( + egraph.get_extract_report(), + Some(ExtractReport::Best { + term: Term::App(s, ..), + .. + }) if s == &Symbol::from("cheap") + )); + // Then if we make one as subsumed, it should give back the variable term + egraph + .parse_and_run_program( + None, + r#" + (subsume (cheap)) + (query-extract (exp)) + "#, + ) + .unwrap(); + assert!(matches!( + egraph.get_extract_report(), + Some(ExtractReport::Best { + term: Term::App(s, ..), + .. + }) if s == &Symbol::from("exp") + )); +} + +fn get_function(egraph: &EGraph, name: &str) -> Function { + egraph.functions.get(&Symbol::from(name)).unwrap().clone() +} +fn get_value(egraph: &EGraph, name: &str) -> Value { + get_function(egraph, name).get(&[]).unwrap() +} + +#[test] +fn test_subsumed_unextractable_rebuild_arg() { + // Tests that a term stays unextractable even after a rebuild after a union would change the value of one of its args + let mut egraph = EGraph::default(); + + egraph + .parse_and_run_program( + None, + r#" + (datatype Math) + (function container (Math) Math) + (function exp () Math :cost 100) + (function cheap () Math) + (function cheap-1 () Math) + ; we make the container cheap so that it will be extracted if possible, but then we mark it as subsumed + ; so the (exp) expr should be extracted instead + (let res (container (cheap))) + (union res (exp)) + (cheap) + (cheap-1) + (subsume (container (cheap))) + "#, + ).unwrap(); + // At this point (cheap) and (cheap-1) should have different values, because they aren't unioned + let orig_cheap_value = get_value(&egraph, "cheap"); + let orig_cheap_1_value = get_value(&egraph, "cheap-1"); + assert_ne!(orig_cheap_value, orig_cheap_1_value); + // Then we can union them + egraph + .parse_and_run_program( + None, + r#" + (union (cheap-1) (cheap)) + "#, + ) + .unwrap(); + egraph.rebuild_nofail(); + // And verify that their values are now the same and different from the original (cheap) value. + let new_cheap_value = get_value(&egraph, "cheap"); + let new_cheap_1_value = get_value(&egraph, "cheap-1"); + assert_eq!(new_cheap_value, new_cheap_1_value); + assert_ne!(new_cheap_value, orig_cheap_value); + // Now verify that if we extract, it still respects the unextractable, even though it's a different values now + egraph + .parse_and_run_program( + None, + r#" + (query-extract res) + "#, + ) + .unwrap(); + let report = egraph.get_extract_report().clone().unwrap(); + let ExtractReport::Best { term, termdag, .. } = report else { + panic!(); + }; + let expr = termdag.term_to_expr(&term); + assert_eq!(expr, Expr::call_no_span(Symbol::from("exp"), vec![])); +} + +#[test] +fn test_subsumed_unextractable_rebuild_self() { + // Tests that a term stays unextractable even after a rebuild after a union change its output value. + let mut egraph = EGraph::default(); + + egraph + .parse_and_run_program( + None, + r#" + (datatype Math) + (function container (Math) Math) + (function exp () Math :cost 100) + (function cheap () Math) + (let x (cheap)) + (subsume (cheap)) + "#, + ) + .unwrap(); + + let orig_cheap_value = get_value(&egraph, "cheap"); + // Then we can union them + egraph + .parse_and_run_program( + None, + r#" + (union (exp) x) + "#, + ) + .unwrap(); + egraph.rebuild_nofail(); + // And verify that the cheap value is now different + let new_cheap_value = get_value(&egraph, "cheap"); + assert_ne!(new_cheap_value, orig_cheap_value); + + // Now verify that if we extract, it still respects the subsumption, even though it's a different values now + egraph + .parse_and_run_program( + None, + r#" + (query-extract x) + "#, + ) + .unwrap(); + let report = egraph.get_extract_report().clone().unwrap(); + let ExtractReport::Best { term, termdag, .. } = report else { + panic!(); + }; + let expr = termdag.term_to_expr(&term); + assert_eq!(expr, Expr::call_no_span(Symbol::from("exp"), vec![])); +} + +#[test] +fn test_subsume_unextractable_insert_and_merge() { + // Example adapted from https://github.com/egraphs-good/egglog/pull/301#pullrequestreview-1756826062 + let mut egraph = EGraph::default(); + + egraph + .parse_and_run_program( + None, + r#" + (datatype Expr + (f Expr) + (Num i64)) + (function exp () Expr :cost 100) + + (f (Num 1)) + (subsume (f (Num 1))) + (f (Num 2)) + + (union (Num 2) (Num 1)) + (union (f (Num 2)) (exp)) + (extract (f (Num 2))) + "#, + ) + .unwrap(); + assert!(matches!( + egraph.get_extract_report(), + Some(ExtractReport::Best { + term: Term::App(s, ..), + .. + }) if s == &Symbol::from("exp") + )); +} + +#[test] +fn test_subsume_unextractable_action_extract_multiple() { + // Test when an expression is set as subsumed, it isn't extracted, like with + // extract multiple + let mut egraph = EGraph::default(); + + egraph + .parse_and_run_program( + None, + " + (datatype Math (Num i64)) + (Num 1) + (union (Num 1) (Num 2)) + (query-extract :variants 2 (Num 1)) + ", + ) + .unwrap(); + // Originally should give back two terms when extracted + let report = egraph.get_extract_report(); + assert!(matches!( + report, + Some(ExtractReport::Variants { terms, .. }) if terms.len() == 2 + )); + // Then if we make one unextractable, it should only give back one term + egraph + .parse_and_run_program( + None, + " + (subsume (Num 2)) + (query-extract :variants 2 (Num 1)) + ", + ) + .unwrap(); + let report = egraph.get_extract_report(); + assert!(matches!( + report, + Some(ExtractReport::Variants { terms, .. }) if terms.len() == 1 + )); +} + +#[test] +fn test_rewrite_subsumed_unextractable() { + // When a rewrite is marked as a subsumed, the lhs should not be extracted + + let mut egraph = EGraph::default(); + + egraph + .parse_and_run_program( + None, + r#" + (datatype Math) + (function exp () Math :cost 100) + (function cheap () Math :cost 1) + (rewrite (cheap) (exp) :subsume) + (cheap) + (run 1) + (extract (cheap)) + "#, + ) + .unwrap(); + // Should give back expenive term, because cheap is unextractable + assert!(matches!( + egraph.get_extract_report(), + Some(ExtractReport::Best { + term: Term::App(s, ..), + .. + }) if s == &Symbol::from("exp") + )); +} +#[test] +fn test_rewrite_subsumed() { + // When a rewrite is marked as a subsumed, the lhs should not be extracted + + let mut egraph = EGraph::default(); + + // If we rerite most-exp to another term, that rewrite shouldnt trigger since its been subsumed. + egraph + .parse_and_run_program( + None, + r#" + (datatype Math) + (function exp () Math :cost 100) + (function most-exp () Math :cost 1000) + (rewrite (most-exp) (exp) :subsume) + (most-exp) + (run 1) + (function cheap () Math :cost 1) + (rewrite (most-exp) (cheap)) + (run 1) + (extract (most-exp)) + "#, + ) + .unwrap(); + assert!(matches!( + egraph.get_extract_report(), + Some(ExtractReport::Best { + term: Term::App(s, ..), + .. + }) if s == &Symbol::from("exp") + )); +} + +#[test] +fn test_subsume() { + // Test that if we mark a term as subsumed than no rewrites will be applied to it. + // We can test this by adding a commutative additon property, and verifying it isn't applied on one of the terms + // but is on the other + let mut egraph = EGraph::default(); + egraph + .parse_and_run_program( + None, + r#" + (datatype Math + (Add Math Math) + (Num i64)) + + (rewrite (Add a b) (Add b a)) + (let x (Add (Num 1) (Num 2))) + (let y (Add (Num 3) (Num 4))) + (subsume (Add (Num 1) (Num 2))) + (run 1) + (extract y 10) + "#, + ) + .unwrap(); + assert!(matches!( + egraph.get_extract_report(), + Some(ExtractReport::Variants { terms, .. }) if terms.len() == 2 + )); + + egraph + .parse_and_run_program( + None, + r#" + ;; add something equal to x that can be extracted: + (function otherConst () Math) + (let other (otherConst)) + (union x other) + (extract x 10) + "#, + ) + .unwrap(); + assert!(matches!( + egraph.get_extract_report(), + Some(ExtractReport::Variants { terms, .. }) if terms.len() == 1 + )); +} + +#[test] +fn test_subsume_primitive() { + // Test that we can subsume a primitive + + let mut egraph = EGraph::default(); + let res = egraph.parse_and_run_program( + None, + r#" + (function one () i64) + (set (one) 1) + (subsume (one)) + "#, + ); + assert!(res.is_ok()); +} + +#[test] +fn test_cant_subsume_merge() { + // Test that we can't subsume something with a merge function + + let mut egraph = EGraph::default(); + let res = egraph.parse_and_run_program( + None, + r#" + (function one () i64 :merge old) + (set (one) 1) + (subsume (one)) + "#, + ); + assert!(res.is_err()); +} + +#[test] +fn test_value_to_classid() { + let mut egraph = EGraph::default(); + + egraph + .parse_and_run_program( + None, + r#" + (datatype Math) + (function exp () Math ) + (exp) + (query-extract (exp)) + "#, + ) + .unwrap(); + let report = egraph.get_extract_report().clone().unwrap(); + let ExtractReport::Best { term, termdag, .. } = report else { + panic!(); + }; + let expr = termdag.term_to_expr(&term); + let (sort, value) = egraph.eval_expr(&expr).unwrap(); + + let serialized = egraph.serialize(SerializeConfig::default()); + let class_id = egraph.value_to_class_id(&sort, &value); + assert!(serialized.class_data.get(&class_id).is_some()); + assert_eq!(value, egraph.class_id_to_value(&class_id)); +} + +#[test] +fn test_serialize_subsume_status() { + let mut egraph = EGraph::default(); + + egraph + .parse_and_run_program( + None, + r#" + (datatype Math) + (function a () Math ) + (function b () Math ) + (a) + (b) + (subsume (a)) + "#, + ) + .unwrap(); + + let serialized = egraph.serialize(SerializeConfig::default()); + let a_id = egraph.to_node_id( + None, + egglog::SerializedNode::Function { + name: ("a").into(), + offset: 0, + }, + ); + let b_id = egraph.to_node_id( + None, + egglog::SerializedNode::Function { + name: "b".into(), + offset: 0, + }, + ); + assert!(serialized.nodes[&a_id].subsumed); + assert!(!serialized.nodes[&b_id].subsumed); +} diff --git a/tests/intersection.egg b/tests/intersection.egg new file mode 100644 index 0000000..b29aed7 --- /dev/null +++ b/tests/intersection.egg @@ -0,0 +1,41 @@ +;; computes "e-graph intersection" + +(datatype Expr + (Var String) + (f Expr)) + +(function intersect (Expr Expr) Expr) + +(rule ( + (= x3 (intersect x1 x2)) + (= f1 (f x1)) + (= f2 (f x2)) +)( + (union (intersect f1 f2) (f x3)) +)) + +(let a1 (Var "a1")) (let a2 (Var "a2")) (let a3 (Var "a3")) +(let b1 (Var "b1")) (let b2 (Var "b2")) (let b3 (Var "b3")) + +;; e-graph 1: f(a) = f(b), f(f(a)) +(let t1 (f (f a1))) +(let fb1 (f b1)) +(union (f a1) fb1) + +;; e-graph 2: f(f(a)) = f(f(b)) +(let t2 (f (f a2))) +(let t2p (f (f b2))) +(union t2 t2p) + +(union (intersect a1 a2) a3) +(union (intersect b1 b2) b3) + +(run 100) + +(let t3 (f (f a3))) +(query-extract :variants 5 t3) + +;; f(f(a)) = f(f(b)) is preserved +(check (= (f (f a3)) (f (f b3)))) +;; but not f(a) = f(b), it was only in e-graph 1 +(check (!= (f a3) (f b3))) \ No newline at end of file diff --git a/tests/interval.egg b/tests/interval.egg new file mode 100644 index 0000000..2c82611 --- /dev/null +++ b/tests/interval.egg @@ -0,0 +1,31 @@ +(datatype Math + (Num Rational) + (Var String) + (Mul Math Math)) + +(function hi (Math) Rational :merge (min old new)) +(function lo (Math) Rational :merge (max old new)) + +(rule ((= mul (Mul a b))) + ((set (lo mul) + (min (min (* (lo a) (lo b)) (* (lo a) (hi b))) + (min (* (hi a) (lo b)) (* (hi a) (hi b))))))) + +(let x (Var "x")) +(let e (Mul x x)) + +(set (lo x) (rational -10 1)) +(set (hi x) (rational 10 1)) + +(run 1) + +(check (= (lo e) (rational -100 1))) + +(rule ((= mul (Mul a a))) + ((set (lo mul) (* (lo a) (lo a))))) + +(run 1) +(check (= (lo e) (rational 100 1))) + +;; testing extraction of rationals +(query-extract (lo e)) diff --git a/tests/knapsack.egg b/tests/knapsack.egg new file mode 100644 index 0000000..e9a918a --- /dev/null +++ b/tests/knapsack.egg @@ -0,0 +1,46 @@ +(datatype expr + (Num i64) + (Add expr expr) + (Max expr expr)) +(rewrite (Add (Num a) (Num b)) (Num (+ a b))) +(rewrite (Max (Num a) (Num b)) (Num (max a b))) + +; List of (weight, value) pairs +(datatype objects + (Cons i64 i64 objects)) +(function NilConst () objects) +(let Nil (NilConst)) + +; Given a capacity and a list of objects, finds the maximum value of a +; collection of objects whose total weight does not exceed the capacity. +(function Knap (i64 objects) expr) + +(rule ((= f (Knap capacity (Cons weight val rest))) (<= weight capacity)) + ((union (Knap capacity (Cons weight val rest)) + (Max + (Add (Num val) (Knap (- capacity weight) rest)) + (Knap capacity rest))))) + +(rule ((= f (Knap capacity (Cons weight val rest))) (> weight capacity)) + ((union (Knap capacity (Cons weight val rest)) + (Knap capacity rest)))) + +(rule ((= f (Knap capacity Nil))) + ((union (Knap capacity Nil) (Num 0)))) + +(let test1 (Knap 13 (Cons 5 5 (Cons 3 3 (Cons 12 12 (Cons 5 5 Nil)))))) + +(let test2 (Knap 5 (Cons 6 6 Nil))) + +(let test3 (Knap 5 (Cons 1 1 (Cons 1 1 (Cons 1 1 Nil))))) + +(let test4 (Knap 15 (Cons 12 40 (Cons 2 20 (Cons 1 20 (Cons 1 10 (Cons 4 100 Nil))))))) + +; turn a (Num n) into n +(function Unwrap (expr) i64) +(rule ((= x (Num n))) ((set (Unwrap (Num n)) n))) + +(run 100) + +(check (= test1 (Num 13))) + diff --git a/tests/lambda.egg b/tests/lambda.egg new file mode 100644 index 0000000..392e64c --- /dev/null +++ b/tests/lambda.egg @@ -0,0 +1,242 @@ +;; NOTE: This file contains several unsafe operations +(datatype Value (Num i64)) +(function TrueConst () Value) +(let True (TrueConst)) +(function FalseConst () Value) +(let False (FalseConst)) +(datatype VarType) +(datatype Term + (Val Value) + (Var VarType) + (Add Term Term) + (Eq Term Term) + (App Term Term) + (Lam VarType Term) + (Let VarType Term Term) + (Fix VarType Term) + (If Term Term Term)) +(function V (String) VarType) +(function From (Term) VarType) + +; All free variables are free, +; but some free variables are more free than others +; Freer variables will only contain variables +; that will affect the evaluation +; of the corresponding term +; e.g., x is free in x - x, but not freer in x - x +(sort StringSet (Set VarType)) +(function freer (Term) StringSet :merge (set-intersect old new)) +(rule ((= e (Val v))) + ((set (freer e) (set-empty)))) +(rule ((= e (Var v))) + ((set (freer e) (set-insert (set-empty) v)))) +(rule ((= e (Add e1 e2)) + (= (freer e1) fv1) + (= (freer e2) fv2)) + ((set (freer e) (set-union fv1 fv2)))) +(rule ((= e (Eq e1 e2)) + (= (freer e1) fv1) + (= (freer e2) fv2)) + ((set (freer e) (set-union fv1 fv2)))) +(rule ((= e (App e1 e2)) + (= (freer e1) fv1) + (= (freer e2) fv2)) + ((set (freer e) (set-union fv1 fv2)))) +(rule ((= e (Lam var body)) + (= (freer body) fv)) + ((set (freer e) (set-remove fv var)))) +(rule ((= e (Let var e1 e2)) + (= (freer e1) fv1) + (= (freer e2) fv2)) + ((set (freer e) (set-union fv1 (set-remove fv2 var))))) +(rule ((= e (Fix var body)) + (= (freer body) fv)) + ((set (freer e) (set-remove fv var)))) +(rule ((= e (If c e1 e2)) + (= (freer c) fv1) + (= (freer e1) fv2) + (= (freer e2) fv3)) + ((set (freer e) (set-union fv1 (set-union fv2 fv3))))) + +;; START evals-to +(function evals-to (Term) Value) + +(rule ((= e (Val val))) + ((union (evals-to e) val))) +(rule ((= e (Add a b)) + (= (Num va) (evals-to a)) + (= (Num vb) (evals-to b))) + ((union (evals-to e) (Num (+ va vb))))) +(rule ((= e (Eq a b)) + (= (evals-to b) (evals-to a))) + ((union (evals-to e) True))) +(rule ((= e (Eq a b)) + (= va (evals-to a)) + (= vb (evals-to b)) + (!= va vb)) ; TODO: if true and false are non-mergeable datatype, + ; we should be able to do != over it + ((union (evals-to e) False))) +(rule ((= v (evals-to e))) + ((union e (Val v)))) +;; END evals-to + +; if-true +(rewrite (If (Val True) then else) then) +; if-false +(rewrite (If (Val False) then else) else) +; if-elim +(rule ((= term (If (Eq (Var x) e) then else))) + ((Let x e then) + (Let x e else))) +(rewrite (If (Eq (Var x) e) then else) else + :when ((= (Let x e then) (Let x e else)))) + +; add-comm +(rewrite (Add a b) (Add b a)) +; add-assoc +(rewrite (Add (Add a b) c) (Add a (Add b c))) +; eq-comm +(rewrite (Eq a b) (Eq b a)) + +; fix +(rewrite (Fix v e) (Let v (Fix v e) e)) +; beta +(rewrite (App (Lam v body) e) (Let v e body)) +; let-app +(rewrite (Let v e (App a b)) (App (Let v e a) (Let v e b))) +; let-add +(rewrite (Let v e (Add a b)) (Add (Let v e a) (Let v e b))) +; let-eq +(rewrite (Let v e (Eq a b)) (Eq (Let v e a) (Let v e b))) +; let-const +(rewrite (Let v e c) c :when ((= const (evals-to c)))) +; let-if +(rewrite (Let v e (If cond then else)) + (If (Let v e cond) (Let v e then) (Let v e else))) +; let-var-same +(rewrite (Let v1 e (Var v1)) e) +; let-var-diff +(rewrite (Let v1 e (Var v2)) (Var v2) :when ((!= v1 v2))) +; let-lam-same +(rewrite (Let v1 e (Lam v1 body)) (Lam v1 body)) +; let-lam-diff +(rewrite (Let v1 e (Lam v2 body)) (Lam v2 (Let v1 e body)) + :when ((!= v1 v2) + (= fvs (freer e)) + (set-not-contains fvs v2))) +(rule ((= expr (Let v1 e (Lam v2 body))) + (!= v1 v2) + (= fvs (freer e)) + (set-contains fvs v2)) + ((union expr (Lam (From expr) (Let v1 e (Let v2 (Var (From expr)) body)))))) + +;; lambda_under +(push) +(let e + (Lam (V "x") + (Add (Val (Num 4)) + (App (Lam (V "y") (Var (V "y"))) (Val (Num 4)))))) +(run 10) +(check (= e (Lam (V "x") (Val (Num 8))))) +(pop) + +;; lambda_if_elim +(push) +(let e2 (If (Eq (Var (V "a")) (Var (V "b"))) + (Add (Var (V "a")) (Var (V "a"))) + (Add (Var (V "a")) (Var (V "b"))))) +(run 10) +(check (= e2 (Add (Var (V "a")) (Var (V "b"))))) +(pop) + +;; lambda_let_simple +(push) +(let e3 (Let (V "x") (Val (Num 0)) + (Let (V "y") (Val (Num 1)) + (Add (Var (V "x")) (Var (V "y")))))) +(run 10) +(check (= e3 (Val (Num 1)))) +(pop) + +;; lambda_capture +(push) +(let e4 (Let (V "x") (Val (Num 1)) + (Lam (V "x") (Var (V "x"))))) +(run 10) +(fail (check (= e4 (Lam (V "x") (Val (Num 1)))))) +(pop) + +;; lambda_capture_free +(push) +(let e5 (Let (V "y") (Add (Var (V "x")) (Var (V "x"))) + (Lam (V "x") (Var (V "y"))))) +(run 10) +(check (set-contains (freer (Lam (V "x") (Var (V "y")))) (V "y"))) +(fail (check (= e5 (Lam (V "x") (Add (Var (V "x")) (Var (V "x"))))))) +(pop) + +;; lambda_closure_not_seven +(push) +(let e6 + (Let (V "five") (Val (Num 5)) + (Let (V "add-five") (Lam (V "x") (Add (Var (V "x")) (Var (V "five")))) + (Let (V "five") (Val (Num 6)) + (App (Var (V "add-five")) (Val (Num 1))))))) +(run 10) +(fail (check (= e6 (Val (Num 7))))) +(check (= e6 (Val (Num 6)))) +(pop) + + +;; lambda_compose +(push) +(let e7 + (Let (V "compose") (Lam (V "f") + (Lam (V "g") + (Lam (V "x") (App (Var (V "f")) + (App (Var (V "g")) + (Var (V "x"))))))) + (Let (V "add1") (Lam (V "y") (Add (Var (V "y")) (Val (Num 1)))) + (App (App (Var (V "compose")) (Var (V "add1"))) (Var (V "add1")))))) +(run 20) +(check (= e7 (Lam x (Add (Var x) (Val (Num 2)))))) +(pop) + +;; lambda_if_simple +(push) +(let e10 (If (Eq (Val (Num 1)) (Val (Num 1))) (Val (Num 7)) (Val (Num 9)))) +(run 4) +(check (= e10 (Val (Num 7)))) +(pop) + +;; lambda_compose_many +(push) +(let e11 + (Let (V "compose") (Lam (V "f") (Lam (V "g") (Lam (V "x") (App (Var (V "f")) + (App (Var (V "g")) (Var (V "x"))))))) + (Let (V "add1") (Lam (V "y") (Add (Var (V "y")) (Val (Num 1)))) + (App (App (Var (V "compose")) (Var (V "add1"))) + (App (App (Var (V "compose")) (Var (V "add1"))) + (App (App (Var (V "compose")) (Var (V "add1"))) + (App (App (Var (V "compose")) (Var (V "add1"))) + (App (App (Var (V "compose")) (Var (V "add1"))) + (App (App (Var (V "compose")) (Var (V "add1"))) + (Var (V "add1"))))))))))) + +(run 30) +(check (= e11 (Lam x (Add (Var x) (Val (Num 7)))))) +(pop) + +;; lambda_if +(push) +(let e8 + (Let (V "zeroone") (Lam (V "x") + (If (Eq (Var (V "x")) (Val (Num 0))) + (Val (Num 0)) + (Val (Num 1)))) + (Add (App (Var (V "zeroone")) (Val (Num 0))) + (App (Var (V "zeroone")) (Val (Num 10))))) +) +(run 20) +(check (= e8 (Val (Num 1)))) +(pop) diff --git a/tests/levenshtein-distance.egg b/tests/levenshtein-distance.egg new file mode 100644 index 0000000..f67e9fd --- /dev/null +++ b/tests/levenshtein-distance.egg @@ -0,0 +1,71 @@ +; Datatypes + +(datatype expr + (Num i64) + (Add expr expr) + (Min expr expr expr)) +(rewrite (Add (Num a) (Num b)) (Num (+ a b))) +(rewrite (Min (Num a) (Num b) (Num c)) (Num (min (min a b) c))) + +; `String` supports limited operations, let's just use it as a char type +(datatype str + (Cons String str)) +(function EmptyConst () str) +(let Empty (EmptyConst)) + +; Length function + +(function Length (str) expr) + +(rule ((= f (Length Empty))) + ((union (Length Empty) (Num 0)))) + +(rule ((= f (Length (Cons c cs)))) + ((union (Length (Cons c cs)) (Add (Num 1) (Length cs))))) + +; EditDist function + +(function EditDist (str str) expr) + +(rule ((= f (EditDist Empty s))) + ((union (EditDist Empty s) (Length s)))) + +(rule ((= f (EditDist s Empty))) + ((union (EditDist s Empty) (Length s)))) + +(rule ((= f (EditDist (Cons head rest1) (Cons head rest2)))) + ((union (EditDist (Cons head rest1) (Cons head rest2)) + (EditDist rest1 rest2)))) + +(rule ((= f (EditDist (Cons head1 rest1) (Cons head2 rest2))) (!= head1 head2)) + ((union (EditDist (Cons head1 rest1) (Cons head2 rest2)) + (Add (Num 1) + (Min (EditDist rest1 rest2) + (EditDist (Cons head1 rest1) rest2) + (EditDist rest1 (Cons head2 rest2))))))) + +; Unwrap function - turn a (Num n) into n + +(function Unwrap (expr) i64) +(rule ((= x (Num n))) ((set (Unwrap (Num n)) n))) + +; Tests +(let HorseStr (Cons "h" (Cons "o" (Cons "r" (Cons "s" (Cons "e" Empty)))))) +(let RosStr (Cons "r" (Cons "o" (Cons "s" Empty)))) +(let IntentionStr (Cons "i" (Cons "n" (Cons "t" (Cons "e" (Cons "n" (Cons "t" (Cons "i" (Cons "o" (Cons "n" Empty)))))))))) +(let ExecutionStr (Cons "e" (Cons "x" (Cons "e" (Cons "c" (Cons "u" (Cons "t" (Cons "i" (Cons "o" (Cons "n" Empty)))))))))) + +(let Test1 (EditDist HorseStr RosStr)) +(let Test2 (EditDist IntentionStr ExecutionStr)) +(let Test3 (EditDist HorseStr Empty)) + +(run 100) + +(extract (Unwrap Test1)) +(check (= Test1 (Num 3))) + +(extract (Unwrap Test2)) +(check (= Test2 (Num 5))) + +(extract (Unwrap Test3)) +(check (= Test3 (Num 5))) \ No newline at end of file diff --git a/tests/list.egg b/tests/list.egg new file mode 100644 index 0000000..31ab5a8 --- /dev/null +++ b/tests/list.egg @@ -0,0 +1,73 @@ +(datatype List + (Nil) + (Cons i64 List)) + +(ruleset list) + +(function list-length (List) i64) +(relation list-length-demand (List)) +(rule + ((list-length-demand (Nil))) + ((set (list-length (Nil)) 0)) + :ruleset list) +(rule + ((list-length-demand (Cons head tail))) + ((list-length-demand tail)) + :ruleset list) +(rule + ( (list-length-demand (Cons head tail)) + (= (list-length tail) tail-length)) + ((set (list-length (Cons head tail)) (+ tail-length 1))) + :ruleset list) + +(function list-get (List i64) i64) +(relation list-get-demand (List i64)) +(rule + ( (list-get-demand list 0) + (= list (Cons head tail))) + ((set (list-get list 0) head)) + :ruleset list) +(rule + ( (list-get-demand list n) (> n 0) + (= list (Cons head tail))) + ((list-get-demand tail (- n 1))) + :ruleset list) +(rule + ( (list-get-demand list n) + (= list (Cons head tail)) + (= item (list-get tail (- n 1)))) + ((set (list-get list n) item)) + :ruleset list) + +(function list-append (List List) List) +(rewrite (list-append (Nil) list) list :ruleset list) +(rewrite (list-append (Cons head tail) list) (Cons head (list-append tail list)) :ruleset list) + +; list-contains Nil _ => false +; list-contains (Cons item tail) item => true +; list-contains (Cons head tail) item => assert(head != item); (list-contains tail item) +; list-contains needs inequality + +(function list-set (List i64 i64) List) +(rewrite (list-set (Cons head tail) 0 item) (Cons item tail) :ruleset list) +(rewrite (list-set (Cons head tail) i item) (Cons head (list-set tail (- i 1) item)) :when ((> i 0)) :ruleset list) + +; Tests +(let a (Cons 1 (Cons 2 (Nil)))) +(let b (Cons 3 (Nil))) +(let c (Cons 1 (Cons 2 (Cons 3 (Nil))))) +(let d (Cons 1 (Cons 4 (Nil)))) +(let e (list-append a b)) +(let f (list-set a 1 4)) + +(list-length-demand c) +(list-get-demand b 0) +(list-get-demand a 1) + +(run-schedule (saturate (run list))) + +(check (= e c)) +(check (= (list-length c) 3)) +(check (= (list-get b 0) 3)) +(check (= (list-get a 1) 2)) +(check (= f d)) diff --git a/tests/map.egg b/tests/map.egg new file mode 100644 index 0000000..51e9897 --- /dev/null +++ b/tests/map.egg @@ -0,0 +1,7 @@ +(sort MyMap (Map i64 String)) + +(let my_map1 (map-insert (map-empty) 1 "one")) +(let my_map2 (map-insert my_map1 2 "two")) + +(check (= "one" (map-get my_map1 1))) +(query-extract my_map2) \ No newline at end of file diff --git a/tests/math-microbenchmark.egg b/tests/math-microbenchmark.egg new file mode 100644 index 0000000..328c974 --- /dev/null +++ b/tests/math-microbenchmark.egg @@ -0,0 +1,73 @@ +(datatype Math + (Diff Math Math) + (Integral Math Math) + + (Add Math Math) + (Sub Math Math) + (Mul Math Math) + (Div Math Math) + (Pow Math Math) + (Ln Math) + (Sqrt Math) + + (Sin Math) + (Cos Math) + + (Const Rational) + (Var String)) + +(rewrite (Add a b) (Add b a)) +(rewrite (Mul a b) (Mul b a)) +(rewrite (Add a (Add b c)) (Add (Add a b) c)) +(rewrite (Mul a (Mul b c)) (Mul (Mul a b) c)) + +(rewrite (Sub a b) (Add a (Mul (Const (rational -1 1)) b))) +;; (rewrite (Div a b) (Mul a (Pow b (Const (rational -1 1)))) :when ((is-not-zero b))) + +(rewrite (Add a (Const (rational 0 1))) a) +(rewrite (Mul a (Const (rational 0 1))) (Const (rational 0 1))) +(rewrite (Mul a (Const (rational 1 1))) a) + +(rewrite (Sub a a) (Const (rational 0 1))) + +(rewrite (Mul a (Add b c)) (Add (Mul a b) (Mul a c))) +(rewrite (Add (Mul a b) (Mul a c)) (Mul a (Add b c))) + +(rewrite (Mul (Pow a b) (Pow a c)) (Pow a (Add b c))) +(rewrite (Pow x (Const (rational 1 1))) x) +(rewrite (Pow x (Const (rational 2 1))) (Mul x x)) + +(rewrite (Diff x (Add a b)) (Add (Diff x a) (Diff x b))) +(rewrite (Diff x (Mul a b)) (Add (Mul a (Diff x b)) (Mul b (Diff x a)))) + +(rewrite (Diff x (Sin x)) (Cos x)) +(rewrite (Diff x (Cos x)) (Mul (Const (rational -1 1)) (Sin x))) + +(rewrite (Integral (Const (rational 1 1)) x) x) +(rewrite (Integral (Cos x) x) (Sin x)) +(rewrite (Integral (Sin x) x) (Mul (Const (rational -1 1)) (Cos x))) +(rewrite (Integral (Add f g) x) (Add (Integral f x) (Integral g x))) +(rewrite (Integral (Sub f g) x) (Sub (Integral f x) (Integral g x))) +(rewrite (Integral (Mul a b) x) +(Sub (Mul a (Integral b x)) + (Integral (Mul (Diff x a) (Integral b x)) x))) +(Integral (Ln (Var "x")) (Var "x")) +(Integral (Add (Var "x") (Cos (Var "x"))) (Var "x")) +(Integral (Mul (Cos (Var "x")) (Var "x")) (Var "x")) +(Diff (Var "x") (Add (Const (rational 1 1)) (Mul (Const (rational 2 1)) (Var "x")))) +(Diff (Var "x") (Sub (Pow (Var "x") (Const (rational 3 1))) (Mul (Const (rational 7 1)) (Pow (Var "x") (Const (rational 2 1)))))) +(Add (Mul (Var "y") (Add (Var "x") (Var "y"))) (Sub (Add (Var "x") (Const (rational 2 1))) (Add (Var "x") (Var "x")))) +(Div (Const (rational 1 1)) + (Sub (Div (Add (Const (rational 1 1)) + (Sqrt (Var "five"))) + (Const (rational 2 1))) + (Div (Sub (Const (rational 1 1)) + (Sqrt (Var "five"))) + (Const (rational 2 1))))) +(run 11) +(print-size Add) +(print-size Mul) + +(print-size) + +(print-stats) \ No newline at end of file diff --git a/tests/math.egg b/tests/math.egg new file mode 100644 index 0000000..127b054 --- /dev/null +++ b/tests/math.egg @@ -0,0 +1,144 @@ +(datatype Math + (Diff Math Math) + (Integral Math Math) + + (Add Math Math) + (Sub Math Math) + (Mul Math Math) + (Div Math Math) + (Pow Math Math) + (Ln Math) + (Sqrt Math) + + (Sin Math) + (Cos Math) + + (Const Rational) + (Var String)) + +(relation MathU (Math)) +(rule ((= e (Diff x y))) ((MathU e))) +(rule ((= e (Integral x y))) ((MathU e))) +(rule ((= e (Add x y))) ((MathU e))) +(rule ((= e (Sub x y))) ((MathU e))) +(rule ((= e (Mul x y))) ((MathU e))) +(rule ((= e (Div x y))) ((MathU e))) +(rule ((= e (Pow x y))) ((MathU e))) +(rule ((= e (Ln x))) ((MathU e))) +(rule ((= e (Sqrt x))) ((MathU e))) +(rule ((= e (Sin x))) ((MathU e))) +(rule ((= e (Cos x))) ((MathU e))) +(rule ((= e (Const x))) ((MathU e))) +(rule ((= e (Var x))) ((MathU e))) + +(relation evals-to (Math Rational)) + +(rule ((= e (Const c))) ((evals-to e c))) +(rule ((= e (Add a b)) (evals-to a va) (evals-to b vb)) + ((evals-to e (+ va vb)))) +(rule ((= e (Sub a b)) (evals-to a va) (evals-to b vb)) + ((evals-to e (- va vb)))) +(rule ((= e (Mul a b)) (evals-to a va) (evals-to b vb)) + ((evals-to e (* va vb)))) +(rule ((= e (Div a b)) (evals-to a va) (evals-to b vb) (!= vb (rational 0 1))) + ((evals-to e (/ va vb)))) +(rule ((evals-to x vx)) ((union x (Const vx)))) + +(relation is-const (Math)) +(rule ((evals-to a va)) ((is-const a))) + +(relation is-sym (Math)) +(rule ((= e (Var s))) ((is-sym e))) + +(relation is-not-zero (Math)) +(rule ((evals-to x vx) + (!= vx (rational 0 1))) + ((is-not-zero x))) + +(relation is-const-or-distinct-var-demand (Math Math)) +(relation is-const-or-distinct-var (Math Math)) +(rule ((is-const-or-distinct-var-demand v w) + (is-const v)) + ((is-const-or-distinct-var v w))) +(rule ((is-const-or-distinct-var-demand v w) + (= v (Var vv)) + (= w (Var vw)) + (!= vv vw)) + ((is-const-or-distinct-var v w))) + +(rewrite (Add a b) (Add b a)) +(rewrite (Mul a b) (Mul b a)) +(rewrite (Add a (Add b c)) (Add (Add a b) c)) +(rewrite (Mul a (Mul b c)) (Mul (Mul a b) c)) + +(rewrite (Sub a b) (Add a (Mul (Const (rational -1 1)) b))) +(rewrite (Div a b) (Mul a (Pow b (Const (rational -1 1)))) :when ((is-not-zero b))) + +(rewrite (Add a (Const (rational 0 1))) a) +(rewrite (Mul a (Const (rational 0 1))) (Const (rational 0 1))) +(rewrite (Mul a (Const (rational 1 1))) a) + +;; NOTE: these two rules are different from math.rs, as math.rs does pruning +(rule ((MathU a) (!= a (Const (rational 0 1)))) ((union a (Add a (Const (rational 0 1)))))) +(rule ((MathU a) (!= a (Const (rational 1 1)))) ((union a (Mul a (Const (rational 1 1)))))) + +(rewrite (Sub a a) (Const (rational 0 1))) +(rewrite (Div a a) (Const (rational 1 1)) :when ((is-not-zero a))) + +(rewrite (Mul a (Add b c)) (Add (Mul a b) (Mul a c))) +(rewrite (Add (Mul a b) (Mul a c)) (Mul a (Add b c))) + +(rewrite (Mul (Pow a b) (Pow a c)) (Pow a (Add b c))) +(rewrite (Pow x (Const (rational 0 1))) (Const (rational 1 1)) :when ((is-not-zero x))) +(rewrite (Pow x (Const (rational 1 1))) x) +(rewrite (Pow x (Const (rational 2 1))) (Mul x x)) +(rewrite (Pow x (Const (rational -1 1))) (Div (Const (rational 1 1)) x) :when ((is-not-zero x))) +(rewrite (Mul x (Div (Const (rational 1 1)) x)) (Const (rational 1 1)) :when ((is-not-zero x))) + +(rewrite (Diff x x) (Const (rational 1 1)) :when ((is-sym x))) +(rule ((= e (Diff x c)) + (is-sym x)) + ((is-const-or-distinct-var-demand c x))) +(rewrite (Diff x c) (Const (rational 0 1)) :when ((is-sym x) (is-const-or-distinct-var c x))) + +(rewrite (Diff x (Add a b)) (Add (Diff x a) (Diff x b))) +(rewrite (Diff x (Mul a b)) (Add (Mul a (Diff x b)) (Mul b (Diff x a)))) + +(rewrite (Diff x (Sin x)) (Cos x)) +(rewrite (Diff x (Cos x)) (Mul (Const (rational -1 1)) (Sin x))) + +(rewrite (Diff x (Ln x)) (Div (Const (rational 1 1)) x) :when ((is-not-zero x))) + +(rewrite (Diff x (Pow f g)) + (Mul (Pow f g) + (Add (Mul (Diff x f) (Div g f)) + (Mul (Diff x g) (Ln f)))) + :when ((is-not-zero f) + (is-not-zero g))) + +(rewrite (Integral (Const (rational 1 1)) x) x) +(rewrite (Integral (Pow x c) x) + (Div (Pow x (Add c (Const (rational 1 1)))) (Add c (Const (rational 1 1)))) + :when ((is-const c))) +(rewrite (Integral (Cos x) x) (Sin x)) +(rewrite (Integral (Sin x) x) (Mul (Const (rational -1 1)) (Cos x))) +(rewrite (Integral (Add f g) x) (Add (Integral f x) (Integral g x))) +(rewrite (Integral (Sub f g) x) (Sub (Integral f x) (Integral g x))) +(rewrite (Integral (Mul a b) x) + (Sub (Mul a (Integral b x)) + (Integral (Mul (Diff x a) (Integral b x)) x))) + + +(let start-expr2 (Add (Const (rational 1 1)) + (Sub (Var "a") + (Mul (Sub (Const (rational 2 1)) + (Const (rational 1 1))) + (Var "a"))))) + +(run 6) + +(let end-expr2 (Const (rational 1 1))) + +(check (= start-expr2 end-expr2)) + +(query-extract start-expr2) \ No newline at end of file diff --git a/tests/matrix.egg b/tests/matrix.egg new file mode 100644 index 0000000..98c03b3 --- /dev/null +++ b/tests/matrix.egg @@ -0,0 +1,98 @@ + +(datatype Dim (Times Dim Dim) (NamedDim String) (Lit i64)) + +(rewrite (Times a (Times b c)) (Times (Times a b) c)) +(rewrite (Times (Times a b) c) (Times a (Times b c)) ) +(rewrite (Times (Lit i) (Lit j)) (Lit (* i j))) +(rewrite (Times a b) (Times b a)) + +(datatype MExpr + (MMul MExpr MExpr) + (Kron MExpr MExpr) + (NamedMat String) + (Id Dim) + ; DSum + ; HStack + ; VStack + ; Transpose + ; Inverse + ; Zero Math Math + ; ScalarMul +) + +; alternative encoding (type A) = (Matrix n m) may be more useful for "large story example" +(function nrows (MExpr) Dim) +(function ncols (MExpr) Dim) + +(rewrite (nrows (Kron A B)) (Times (nrows A) (nrows B))) +(rewrite (ncols (Kron A B)) (Times (ncols A) (ncols B))) + +(rewrite (nrows (MMul A B)) (nrows A)) +(rewrite (ncols (MMul A B)) (ncols B)) + +(rewrite (nrows (Id n)) n) +(rewrite (ncols (Id n)) n) + +(rewrite (MMul (Id n) A) A) +(rewrite (MMul A (Id n)) A) + +(rewrite (MMul A (MMul B C)) (MMul (MMul A B) C)) +(rewrite (MMul (MMul A B) C) (MMul A (MMul B C))) + +(rewrite (Kron A (Kron B C)) (Kron (Kron A B) C)) +(rewrite (Kron (Kron A B) C) (Kron A (Kron B C))) + +(rewrite (Kron (MMul A C) (MMul B D)) (MMul (Kron A B) (Kron C D))) + + +(rewrite (MMul (Kron A B) (Kron C D)) + (Kron (MMul A C) (MMul B D)) + :when + ((= (ncols A) (nrows C)) + (= (ncols B) (nrows D))) +) + +; demand +(rule ((= e (MMul A B))) +((ncols A) +(nrows A) +(ncols B) +(nrows B)) +) + +(rule ((= e (Kron A B))) +((ncols A) +(nrows A) +(ncols B) +(nrows B)) +) + + +(let n (NamedDim "n")) +(let m (NamedDim "m")) +(let p (NamedDim "p")) + +(let A (NamedMat "A")) +(let B (NamedMat "B")) +(let C (NamedMat "C")) + +(union (nrows A) n) +(union (ncols A) n) +(union (nrows B) m) +(union (ncols B) m) +(union (nrows C) p) +(union (ncols C) p) +(let ex1 (MMul (Kron (Id n) B) (Kron A (Id m)))) +(let rows1 (nrows ex1)) +(let cols1 (ncols ex1)) + +(run 20) + +(check (= (nrows B) m)) +(check (= (nrows (Kron (Id n) B)) (Times n m))) +(let simple_ex1 (Kron A B)) +(check (= ex1 simple_ex1)) + +(let ex2 (MMul (Kron (Id p) C) (Kron A (Id m)))) +(run 10) +(fail (check (= ex2 (Kron A C)))) diff --git a/tests/merge-during-rebuild.egg b/tests/merge-during-rebuild.egg new file mode 100644 index 0000000..326705b --- /dev/null +++ b/tests/merge-during-rebuild.egg @@ -0,0 +1,18 @@ +; This file tests that non-union merges can be triggered during rebuilds as well +; as "inline" during a set action. See issue #42 + +(datatype N (Node i64)) +(function distance (N N) i64 :merge (min old new)) + +(let a (Node 0)) +(let b (Node 1)) +(let x (Node 2)) +(let y (Node 3)) +(set (distance x y) 1) +(set (distance a b) 2) + +(union a x) +(union b y) + +(run 1) +(check (= (distance x y) 1)) ; fails, the distance has gone up! diff --git a/tests/merge-saturates.egg b/tests/merge-saturates.egg new file mode 100644 index 0000000..46f0d10 --- /dev/null +++ b/tests/merge-saturates.egg @@ -0,0 +1,24 @@ +(function foo () i64 :merge (min old new)) + +(set (foo) 0) + +; This should break at iteration 0 because the merge doesn't cause any updates +(rule ((= f (foo))) ((set (foo) 1))) +(run 100) + + +; This should run for about 50 iterations, because even though the merge doesn't +; change the value of baz, it has a side effect of expanding the domain of bar. + +(function baz (i64) i64 :default 0) + +(function bar () i64 :merge (min (baz new) 0)) + +(set (bar) 1) +(set (bar) 2) + +(rule ((= f (baz x)) (< x 50)) + ((set (bar) (+ x 1)))) + +(run 100) +(check (= 0 (baz 50))) diff --git a/tests/multiset.egg b/tests/multiset.egg new file mode 100644 index 0000000..795281c --- /dev/null +++ b/tests/multiset.egg @@ -0,0 +1,58 @@ +(datatype Math (Num i64)) +(sort MathToMath (UnstableFn (Math) Math)) +(sort Maths (MultiSet Math)) + +(let xs (multiset-of (Num 1) (Num 2) (Num 3))) + +;; verify equal to other ordering +(check (= + (multiset-of (Num 3) (Num 2) (Num 1)) + xs +)) + +;; verify not equal to different counts +(check (!= + (multiset-of (Num 3) (Num 2) (Num 1) (Num 1)) + xs +)) + +;; Unclear why check won't work if this is defined inline +(let inserted (multiset-insert xs (Num 4))) +;; insert +(check (= + (multiset-of (Num 1) (Num 2) (Num 3) (Num 4)) + inserted +)) + + +;; contains and not contains +(check (multiset-contains xs (Num 1))) +(check (multiset-not-contains xs (Num 4))) + +;; remove last +(check (= + (multiset-of (Num 1) (Num 3)) + (multiset-remove xs (Num 2)) +)) +;; remove one of +(check (= (multiset-of (Num 1)) (multiset-remove (multiset-of (Num 1) (Num 1)) (Num 1)))) + + +;; length +(check (= 3 (multiset-length xs))) +;; length repeated +(check (= 3 (multiset-length (multiset-of (Num 1) (Num 1) (Num 1))))) + +;; pick +(check (= (Num 1) (multiset-pick (multiset-of (Num 1))))) + +;; map +(function square (Math) Math) +(rewrite (square (Num x)) (Num (* x x))) + +(let squared-xs (unstable-multiset-map (unstable-fn "square") xs)) +(run 1) +(check (= + (multiset-of (Num 1) (Num 4) (Num 9)) + squared-xs +)) diff --git a/tests/name-resolution.egg b/tests/name-resolution.egg new file mode 100644 index 0000000..2ef292c --- /dev/null +++ b/tests/name-resolution.egg @@ -0,0 +1,25 @@ +(datatype Math + (Add Math Math) + (Num i64)) + +(let zero (Num 0)) + + +;; zero here refers to the function/constant zero, not a free variable +(rewrite (Add zero x) x) + +(let a (Add (Num 0) (Num 3))) +(let b (Add (Num 7) (Num 9))) +(let c (Num 16)) +(union b c) + +;; crash if we merge two numbers +(rule ( + (= (Num x) (Num y)) + (!= x y) +)( + (panic "ahhh") +)) + + +(run 10) \ No newline at end of file diff --git a/tests/path-union.egg b/tests/path-union.egg new file mode 100644 index 0000000..8f2b631 --- /dev/null +++ b/tests/path-union.egg @@ -0,0 +1,21 @@ +(datatype Node + (mk i64)) + +(relation edge (Node Node)) +(relation path (Node Node)) + +(rule ((edge x y)) + ((path x y))) + +(rule ((path x y) (edge y z)) + ((path x z))) + +(edge (mk 1) (mk 2)) +(edge (mk 2) (mk 3)) +(edge (mk 5) (mk 6)) + +(union (mk 3) (mk 5)) + +(run 10) +(check (edge (mk 3) (mk 6))) +(check (path (mk 1) (mk 6))) \ No newline at end of file diff --git a/tests/path.egg b/tests/path.egg new file mode 100644 index 0000000..6287c03 --- /dev/null +++ b/tests/path.egg @@ -0,0 +1,19 @@ +(relation path (i64 i64)) +(relation edge (i64 i64)) + +(rule ((edge x y)) + ((path x y))) + +(rule ((path x y) (edge y z)) + ((path x z))) + +(edge 1 2) +(edge 2 3) +(edge 3 4) +(check (edge 1 2)) +(fail (check (path 1 2))) +(run 3) + +(print-function path 100) +(check (path 1 4)) +(fail (check (path 4 1))) diff --git a/tests/pathproof.egg b/tests/pathproof.egg new file mode 100644 index 0000000..f158ddf --- /dev/null +++ b/tests/pathproof.egg @@ -0,0 +1,30 @@ +; proofs of connectivity are paths +(datatype Proof + (Trans i64 Proof) + (Edge i64 i64)) + +; We enhance the path relation to carry a proof field +(relation path (i64 i64 Proof)) +(relation edge (i64 i64)) + +(edge 2 1) +(edge 3 2) +(edge 1 3) + +(rule ((edge x y)) + ((path x y (Edge x y)))) +(rule ((edge x y) (path y z p)) + ((path x z (Trans x p)))) + +; We consider equal all paths tha connect same points. +; Smallest Extraction will extract shortest path. +(rule ((path x y p1) (path x y p2)) + ((union p1 p2))) + +(run 3) +(check (path 3 1 (Trans 3 (Edge 2 1)))) +; Would prefer being able to check +;(check (path 1 2 _)) +; or extract +;(query-extract (path 1 4 ?p)) +(print-function path 100) \ No newline at end of file diff --git a/tests/points-to.egg b/tests/points-to.egg new file mode 100644 index 0000000..a4401f3 --- /dev/null +++ b/tests/points-to.egg @@ -0,0 +1,63 @@ +; Identifiers represented as strings, keep some newtypes around to aid clarity +(datatype ClassT (Class String)) +(datatype FieldT (Field String)) + +(datatype Stmt + (New String ClassT) + ; Assign dst src + (Assign String String) + ; Store dst field src + (Store String FieldT String) + ; Load dst src field + (Load String String FieldT)) + +(relation VarPointsTo (String ClassT)) +(relation HeapPointsTo (ClassT FieldT ClassT)) + +; New variables point to classes they're initialized as +(rule ((= x (New a b))) ((VarPointsTo a b))) + +; If I assign v1 <- v2 and v2 points to a class c2, then v1 points to class c2 +; as well +(rule ((= x (Assign v1 v2)) (VarPointsTo v2 c2)) + ((VarPointsTo v1 c2))) + +; If c1.f points to c2, and v2 points to class c1, then assigning v1 <- v2.f +; means v1 points to c2 +(rule ((= x (Load v1 v2 f)) + (VarPointsTo v2 c1) + (HeapPointsTo c1 f c2)) + ((VarPointsTo v1 c2))) + +; If v1 points to class c1, and v2 to c2, and if v1.f <- v2, then c1.f points to +; c2 +(rule ((= x (Store v1 f v2)) + (VarPointsTo v1 c1) + (VarPointsTo v2 c2)) + ((HeapPointsTo c1 f c2))) + +; Example in "From Datalog to Flix" +; l1: ClassA o1 = new ClassA(); +; l2: ClassB o2 = new ClassB(); +; l3: ClassB o3 = o2; +; l4: o2.f = o1; +; l5: Object r = o3.f; + +(let A (Class "A")) +(let B (Class "B")) +(let f (Field "f")) + +(let l1 (New "o1" A)) +(let l2 (New "o2" B)) +(let l3 (Assign "o3" "o2")) +(let l4 (Store "o2" f "o1")) +(let l5 (Load "r" "o3" f)) + +(run 3) + +(check (VarPointsTo "o1" A)) +(check (VarPointsTo "o2" B)) + +(check (VarPointsTo "o3" B)) +(check (HeapPointsTo B f A)) +(check (VarPointsTo "r" A)) \ No newline at end of file diff --git a/tests/primitives.egg b/tests/primitives.egg new file mode 100644 index 0000000..a0239e9 --- /dev/null +++ b/tests/primitives.egg @@ -0,0 +1,5 @@ +(check (= (+ 2 2) 4)) +(check (= (- 2 1) 1)) +(check (= (- 1 2) -1)) +(check (< 1 2)) +(check (> 1 -2)) \ No newline at end of file diff --git a/tests/prims.egg b/tests/prims.egg new file mode 100644 index 0000000..fcfcb2e --- /dev/null +++ b/tests/prims.egg @@ -0,0 +1,124 @@ +; A nasty, imperative implementation of Prim's algorithm... in egglog! +; https://en.wikipedia.org/wiki/Prim%27s_algorithm + +; Weighted edge (vertex 1 * vertex 2 * weight) +(datatype edge (Edge i64 i64 i64)) +(relation edge-exists (edge)) + +(relation mytrue ()) +(mytrue) +(let infinity 99999999) ; close enough + +; ==== PROBLEM INSTANCES ==== + +; Graph 1 +; (1)--2--(2) +; \ | +; 1 2 +; \ | +; (3)--3--(4) +(ruleset graph1) +(rule ((mytrue)) + ((edge-exists (Edge 1 2 2)) + (edge-exists (Edge 1 4 1)) + (edge-exists (Edge 2 4 2)) + (edge-exists (Edge 3 4 3))) + :ruleset graph1) + +; Graph 2 +; (1)-2-(2) (3) +; |\ /| / | +; | 3 5 | 4 | +; 5 X 2 / 5 +; | / \ |/ | +; (4)-4-(5)-7-(6) +(ruleset graph2) +(rule ((mytrue)) + ((edge-exists (Edge 1 2 1)) + (edge-exists (Edge 1 4 5)) + (edge-exists (Edge 1 5 3)) + (edge-exists (Edge 2 4 5)) + (edge-exists (Edge 2 5 2)) + (edge-exists (Edge 3 5 4)) + (edge-exists (Edge 3 6 5)) + (edge-exists (Edge 4 5 4)) + (edge-exists (Edge 5 6 7))) + :ruleset graph2) + +; ==== "INIT" RULESET ==== + +(ruleset init) + +; Graph is undirected +(rule ((= e (Edge x y weight))) + ((union e (Edge y x weight))) + :ruleset init) + +; Whether a vertex is included *so far* (this changes). Returns 0 or 1. +(function vertex-included (i64) i64 :merge (max old new)) + +; All vertices default to being not included (note vertex-included's :merge) +(rule ((edge-exists (Edge x y weight))) + ((set (vertex-included x) 0)) + :ruleset init) + +; Keep track of the current iteration +(function current-iteration () i64 :merge (max old new)) + +; Map iteration to best edge found so far +(function iteration-to-best-edge (i64) edge :merge new) +(function iteration-to-best-edge-weight (i64) i64 :merge new) + +(rule ((mytrue)) + ((set (vertex-included 1) 1) ; Initially just include vertex 1 + (set (current-iteration) 0) + (set (iteration-to-best-edge-weight 0) infinity)) + :ruleset init) + +; === "CHOOSE BEST EDGE" RULESET === + +(relation edge-in-mst (edge)) ; whether an edge is in our solution + +(ruleset choose-best-edge) +(rule ((= i (current-iteration)) + (edge-exists (Edge x y weight)) + (= 1 (vertex-included x)) + (= 0 (vertex-included y)) + (< weight (iteration-to-best-edge-weight i))) + ((set (iteration-to-best-edge-weight i) weight) + (set (iteration-to-best-edge i) (Edge x y weight))) + :ruleset choose-best-edge) + +; === "FINISH ITERATION" RULESET === + +(ruleset finish-iteration) +(rule ((= i (current-iteration)) + (= (Edge x y weight) (iteration-to-best-edge i))) + ((edge-in-mst (Edge x y weight)) ; incorporate chosen best edge + (set (vertex-included x) 1) ; mark its vertices as included + (set (vertex-included y) 1) + (set (current-iteration) (+ i 1)) ; advance iteration + (set (iteration-to-best-edge-weight (+ i 1)) infinity)) + :ruleset finish-iteration) + +; === RUN VIA SCHEDULE === + +(run-schedule + (saturate init graph1) ; change to graph2 to see other example + (saturate (saturate choose-best-edge) finish-iteration) +) + +; === PRINT RESULTS === + +; (print-function edge-in-mst) ; this is not very helpful + +; Just copy canonical edges to solution +(relation solution (i64 i64 i64)) + +(ruleset finalize) +(rule ((edge-in-mst (Edge x y weight)) (< x y)) + ((solution x y weight)) + :ruleset finalize) +(run-schedule (saturate finalize)) + +(print-function solution 100) ; this is better diff --git a/tests/push-pop.egg b/tests/push-pop.egg new file mode 100644 index 0000000..64aa297 --- /dev/null +++ b/tests/push-pop.egg @@ -0,0 +1,11 @@ +(function foo () i64 :merge (max old new)) + +(set (foo) 1) +(check (= (foo) 1)) + +(push) +(set (foo) 2) +(check (= (foo) 2)) +(pop) + +(check (= (foo) 1)) \ No newline at end of file diff --git a/tests/python_array_optimize.egg b/tests/python_array_optimize.egg new file mode 100644 index 0000000..0e2b1bb --- /dev/null +++ b/tests/python_array_optimize.egg @@ -0,0 +1,1569 @@ +;; created by `python python/tests/test_array_api.py` +(push 1) +(sort DType) +(function DType_float64 () DType) +(let %__expr_2565664028803046192 (DType_float64)) +(sort Boolean) +(function DType___eq__ (DType DType) Boolean) +(sort NDArray) +(function NDArray_dtype (NDArray) DType) +(function assume_isfinite (NDArray) NDArray) +(sort TupleInt) +(function assume_shape (NDArray TupleInt) NDArray) +(function assume_dtype (NDArray DType) NDArray) +(function NDArray_var (String) NDArray :cost 200) +(sort Int) +(sort Vec_Int (Vec Int)) +(function TupleInt_from_vec (Vec_Int) TupleInt) +(function Int___init__ (i64) Int) +(DType___eq__ %__expr_2565664028803046192 (NDArray_dtype (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))))) +(ruleset array_api_ruleset) +(function i-Int__-Int_i (Int Int) Int) +(rewrite (i-Int__-Int_i i _) i :ruleset array_api_ruleset) +(function TupleInt_single (Int) TupleInt) +(sort UnstableFn_Int_Int (UnstableFn (Int) Int)) +(function TupleInt___init__ (Int UnstableFn_Int_Int) TupleInt :unextractable) +(rewrite (TupleInt_single i) (TupleInt___init__ (Int___init__ 1) (unstable-fn "i-Int__-Int_i" i)) :ruleset array_api_ruleset) +(function i-Int_i (Int) Int) +(rewrite (i-Int_i i) i :ruleset array_api_ruleset) +(function TupleInt_range (Int) TupleInt) +(rewrite (TupleInt_range stop) (TupleInt___init__ stop (unstable-fn "i-Int_i")) :ruleset array_api_ruleset) +(function index_vec_int (Vec_Int Int) Int) +(rewrite (TupleInt_from_vec vec) (TupleInt___init__ (Int___init__ (vec-length vec)) (unstable-fn "index_vec_int" vec)) :ruleset array_api_ruleset) +(function Int_if_ (Boolean Int Int) Int) +(function Int___lt__ (Int Int) Boolean) +(function TupleInt_length (TupleInt) Int) +(function TupleInt___getitem__ (TupleInt Int) Int) +(function Int___sub__ (Int Int) Int) +(function other-TupleInt_self-TupleInt_i-Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____ (TupleInt TupleInt Int) Int) +(rewrite (other-TupleInt_self-TupleInt_i-Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____ other self i) (Int_if_ (Int___lt__ i (TupleInt_length self)) (TupleInt___getitem__ self i) (TupleInt___getitem__ other (Int___sub__ i (TupleInt_length self)))) :ruleset array_api_ruleset) +(function TupleInt___add__ (TupleInt TupleInt) TupleInt) +(function Int___add__ (Int Int) Int) +(rewrite (TupleInt___add__ self other) (TupleInt___init__ (Int___add__ (TupleInt_length self) (TupleInt_length other)) (unstable-fn "other-TupleInt_self-TupleInt_i-Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____" other self)) :ruleset array_api_ruleset) +(function Boolean___or__ (Boolean Boolean) Boolean) +(function Int___eq__ (Int Int) Boolean) +(function i-Int_acc-Boolean_j-Int__Boolean___or___acc__Int___eq___i_j__ (Int Boolean Int) Boolean) +(rewrite (i-Int_acc-Boolean_j-Int__Boolean___or___acc__Int___eq___i_j__ i acc j) (Boolean___or__ acc (Int___eq__ i j)) :ruleset array_api_ruleset) +(function TupleInt_contains (TupleInt Int) Boolean) +(sort UnstableFn_Boolean_Boolean_Int (UnstableFn (Boolean Int) Boolean)) +(function TupleInt_fold_boolean (TupleInt Boolean UnstableFn_Boolean_Boolean_Int) Boolean) +(function FALSE () Boolean) +(rewrite (TupleInt_contains self i) (TupleInt_fold_boolean self (FALSE) (unstable-fn "i-Int_acc-Boolean_j-Int__Boolean___or___acc__Int___eq___i_j__" i)) :ruleset array_api_ruleset) +(function f-UnstableFn_Int_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__ (UnstableFn_Int_Int TupleInt Int) Int) +(rewrite (f-UnstableFn_Int_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__ f self i) (unstable-app f (TupleInt___getitem__ self i)) :ruleset array_api_ruleset) +(function TupleInt_map (TupleInt UnstableFn_Int_Int) TupleInt :cost 100) +(rewrite (TupleInt_map self f) (TupleInt___init__ (TupleInt_length self) (unstable-fn "f-UnstableFn_Int_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__" f self)) :ruleset array_api_ruleset) +(function NDArray_size (NDArray) Int) +(sort UnstableFn_Int_Int_Int (UnstableFn (Int Int) Int)) +(function TupleInt_fold (TupleInt Int UnstableFn_Int_Int_Int) Int) +(function NDArray_shape (NDArray) TupleInt) +(function Int___mul__ (Int Int) Int) +(rewrite (NDArray_size x) (TupleInt_fold (NDArray_shape x) (Int___init__ 1) (unstable-fn "Int___mul__")) :ruleset array_api_ruleset) +(function unique_values (NDArray) NDArray) +(sort TupleValue) +(function NDArray_vector (TupleValue) NDArray) +(sort Value) +(function possible_values (Value) TupleValue) +(function NDArray_index (NDArray TupleInt) Value) +(function ALL_INDICES () TupleInt) +(rewrite (unique_values a) (NDArray_vector (possible_values (NDArray_index a (ALL_INDICES)))) :ruleset array_api_ruleset) +(function Value_isfinite (Value) Boolean) +(function Value_int (Int) Value) +(function TRUE () Boolean) +(rewrite (Value_isfinite (Value_int i)) (TRUE) :ruleset array_api_ruleset) +(function Value_bool (Boolean) Value) +(rewrite (Value_isfinite (Value_bool b)) (TRUE) :ruleset array_api_ruleset) +(sort Float) +(function Value_float (Float) Value) +(function Float___init__ (f64) Float :cost 3) +(rewrite (Value_isfinite (Value_float (Float___init__ f))) (TRUE) :when ((!= f NaN)) :ruleset array_api_ruleset) +(function isfinite (NDArray) NDArray) +(sort OptionalIntOrTuple) +(function sum (NDArray OptionalIntOrTuple) NDArray) +(function OptionalIntOrTuple_none () OptionalIntOrTuple) +(function NDArray_scalar (Value) NDArray) +(rewrite (isfinite (sum arr (OptionalIntOrTuple_none))) (NDArray_scalar (Value_bool (Value_isfinite (NDArray_index arr (ALL_INDICES))))) :ruleset array_api_ruleset) +(function assume_value_one_of (NDArray TupleValue) NDArray) +(rewrite (NDArray_shape (assume_value_one_of x vs)) (NDArray_shape x) :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (assume_value_one_of x vs)) (NDArray_dtype x) :ruleset array_api_ruleset) +(rule ((= v (NDArray_index (assume_value_one_of x vs) idx))) + ((union v (NDArray_index x idx)) + (union (possible_values v) vs)) + :ruleset array_api_ruleset ) +(rewrite (NDArray_shape (assume_isfinite x)) (NDArray_shape x) :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (assume_isfinite x)) (NDArray_dtype x) :ruleset array_api_ruleset) +(rewrite (NDArray_index (assume_isfinite x) ti) (NDArray_index x ti) :ruleset array_api_ruleset) +(rewrite (Value_isfinite (NDArray_index (assume_isfinite x) ti)) (TRUE) :ruleset array_api_ruleset) +(rewrite (NDArray_shape (assume_shape x shape)) shape :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (assume_shape x shape)) (NDArray_dtype x) :ruleset array_api_ruleset) +(rewrite (NDArray_index (assume_shape x shape) idx) (NDArray_index x idx) :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (assume_dtype x dtype)) dtype :ruleset array_api_ruleset) +(rewrite (NDArray_shape (assume_dtype x dtype)) (NDArray_shape x) :ruleset array_api_ruleset) +(rewrite (NDArray_index (assume_dtype x dtype) idx) (NDArray_index x idx) :ruleset array_api_ruleset) +(sort IndexKey) +(function NDArray___getitem__ (NDArray IndexKey) NDArray) +(function IndexKey_int (Int) IndexKey) +(rewrite (NDArray___getitem__ x (IndexKey_int i)) (NDArray_scalar (NDArray_index x (TupleInt_single i))) :ruleset array_api_ruleset) +(sort OptionalBool) +(function reshape (NDArray TupleInt OptionalBool) NDArray) +(rule ((= __a (reshape x shape copy))) + ((NDArray_shape x) + (TupleInt_length (NDArray_shape x))) + :ruleset array_api_ruleset ) +(rule ((reshape x shape copy)) + ((TupleInt_length shape) + (TupleInt___getitem__ shape (Int___init__ 0))) + :ruleset array_api_ruleset ) +(rewrite (reshape x shape copy) x :when ((= (TupleInt_length (NDArray_shape x)) (Int___init__ 1)) (= (TupleInt_length shape) (Int___init__ 1)) (= (TupleInt___getitem__ shape (Int___init__ 0)) (Int___init__ -1))) :ruleset array_api_ruleset) +(function TupleValue_length (TupleValue) Int) +(rewrite (NDArray_shape (NDArray_vector vs)) (TupleInt_single (TupleValue_length vs)) :ruleset array_api_ruleset) +(function Value_dtype (Value) DType) +(function TupleValue___getitem__ (TupleValue Int) Value) +(rewrite (NDArray_dtype (NDArray_vector vs)) (Value_dtype (TupleValue___getitem__ vs (Int___init__ 0))) :ruleset array_api_ruleset) +(rewrite (NDArray_index (NDArray_vector vs) ti) (TupleValue___getitem__ vs (TupleInt___getitem__ ti (Int___init__ 0))) :ruleset array_api_ruleset) +(function TupleInt_EMPTY () TupleInt) +(rewrite (NDArray_shape (NDArray_scalar v)) (TupleInt_EMPTY) :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (NDArray_scalar v)) (Value_dtype v) :ruleset array_api_ruleset) +(rewrite (NDArray_index (NDArray_scalar v) (TupleInt_EMPTY)) v :ruleset array_api_ruleset) +(function any (NDArray) NDArray) +(function TupleValue_includes (TupleValue Value) Boolean) +(function Value_to_truthy_value (Value) Value) +(rewrite (any x) (NDArray_scalar (Value_bool (TupleValue_includes (possible_values (Value_to_truthy_value (NDArray_index x (ALL_INDICES)))) (Value_bool (TRUE))))) :ruleset array_api_ruleset) +(function NDArray___lt__ (NDArray NDArray) NDArray) +(function Value___lt__ (Value Value) Value) +(function broadcast_index (TupleInt TupleInt TupleInt) TupleInt) +(function broadcast_shapes (TupleInt TupleInt) TupleInt) +(rewrite (NDArray_index (NDArray___lt__ x y) idx) (Value___lt__ (NDArray_index x (broadcast_index (NDArray_shape x) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx)) (NDArray_index y (broadcast_index (NDArray_shape y) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx))) :ruleset array_api_ruleset) +(function NDArray___truediv__ (NDArray NDArray) NDArray) +(function Value___truediv__ (Value Value) Value) +(rewrite (NDArray_index (NDArray___truediv__ x y) idx) (Value___truediv__ (NDArray_index x (broadcast_index (NDArray_shape x) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx)) (NDArray_index y (broadcast_index (NDArray_shape y) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx))) :ruleset array_api_ruleset) +(rewrite (NDArray_index (NDArray_scalar v) idx) v :ruleset array_api_ruleset) +(function astype (NDArray DType) NDArray) +(function Value_astype (Value DType) Value) +(rewrite (NDArray_index (astype x dtype) idx) (Value_astype (NDArray_index x idx) dtype) :ruleset array_api_ruleset) +(relation greater_zero (Value)) +(sort TupleNDArray) +(function TupleNDArray___getitem__ (TupleNDArray Int) NDArray) +(function unique_counts (NDArray) TupleNDArray) +(rule ((= v (NDArray_index (TupleNDArray___getitem__ (unique_counts x) (Int___init__ 1)) idx))) + ((greater_zero v)) + :ruleset array_api_ruleset ) +(rule ((greater_zero v) + (= v1 (Value_astype v dtype))) + ((greater_zero v1)) + :ruleset array_api_ruleset ) +(rule ((= v (Value_float (Float___init__ f))) + (> f 0.0)) + ((greater_zero v)) + :ruleset array_api_ruleset ) +(rule ((= v (Value_int (Int___init__ i))) + (> i 0)) + ((greater_zero v)) + :ruleset array_api_ruleset ) +(rule ((greater_zero v) + (greater_zero v1) + (= v2 (Value___truediv__ v v1))) + ((greater_zero v2)) + :ruleset array_api_ruleset ) +(rule ((greater_zero v) + (= v1 (Value___lt__ v (Value_int (Int___init__ 0))))) + ((union v1 (Value_bool (FALSE)))) + :ruleset array_api_ruleset ) +(function TupleValue___init__ (Value) TupleValue) +(rewrite (possible_values (Value_bool b)) (TupleValue___init__ (Value_bool b)) :ruleset array_api_ruleset) +(rule ((= v1 (Value_astype v dtype)) + (greater_zero v)) + ((greater_zero v1)) + :ruleset array_api_ruleset ) +(function TupleNDArray_length (TupleNDArray) Int) +(function svd (NDArray Boolean) TupleNDArray) +(rewrite (TupleNDArray_length (svd x full_matrices)) (Int___init__ 3) :ruleset array_api_ruleset) +(function unique_inverse (NDArray) TupleNDArray) +(rewrite (TupleNDArray_length (unique_inverse x)) (Int___init__ 2) :ruleset array_api_ruleset) +(rewrite (TupleNDArray___getitem__ (unique_inverse x) (Int___init__ 0)) (unique_values x) :ruleset array_api_ruleset) +(function ndarray-abs (NDArray) NDArray) +(function Float_abs (Float) Float) +(rewrite (ndarray-abs (NDArray_scalar (Value_float f))) (NDArray_scalar (Value_float (Float_abs f))) :ruleset array_api_ruleset) +(rewrite (TupleNDArray_length (unique_counts x)) (Int___init__ 2) :ruleset array_api_ruleset) +(rewrite (sum (TupleNDArray___getitem__ (unique_counts x) (Int___init__ 1)) (OptionalIntOrTuple_none)) (NDArray_scalar (Value_int (NDArray_size x))) :ruleset array_api_ruleset) +(rewrite (sum (astype (TupleNDArray___getitem__ (unique_counts x) (Int___init__ 1)) dtype) (OptionalIntOrTuple_none)) (astype (NDArray_scalar (Value_int (NDArray_size x))) dtype) :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (astype x dtype)) dtype :ruleset array_api_ruleset) +(rewrite (astype (NDArray_scalar (Value_int (Int___init__ i))) %__expr_2565664028803046192) (NDArray_scalar (Value_float (Float___init__ (to-f64 i)))) :ruleset array_api_ruleset) +(sort OptionalInt) +(function concat (TupleNDArray OptionalInt) NDArray) +(function TupleNDArray___init__ (NDArray) TupleNDArray) +(function OptionalInt_none () OptionalInt) +(rewrite (concat (TupleNDArray___init__ x) (OptionalInt_none)) x :ruleset array_api_ruleset) +(rewrite (unique_values (unique_values x)) (unique_values x) :ruleset array_api_ruleset) +(rewrite (sum (NDArray___truediv__ x (NDArray_scalar v)) (OptionalIntOrTuple_none)) (NDArray___truediv__ (sum x (OptionalIntOrTuple_none)) (NDArray_scalar v)) :ruleset array_api_ruleset) +(function NDArray_ndim (NDArray) Int) +(sort OptionalDType) +(sort OptionalDevice) +(function asarray (NDArray OptionalDType OptionalBool OptionalDevice) NDArray) +(function OptionalDevice_none () OptionalDevice) +(rewrite (NDArray_ndim (asarray a d ob (OptionalDevice_none))) (NDArray_ndim a) :ruleset array_api_ruleset) +(function OptionalDType_none () OptionalDType) +(function OptionalBool_none () OptionalBool) +(rewrite (asarray a (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) a :ruleset array_api_ruleset) +(function TupleNDArray___add__ (TupleNDArray TupleNDArray) TupleNDArray) +(function TupleNDArray_EMPTY () TupleNDArray) +(rewrite (TupleNDArray___add__ ti (TupleNDArray_EMPTY)) ti :ruleset array_api_ruleset) +(rewrite (TupleNDArray_length (TupleNDArray___init__ n)) (Int___init__ 1) :ruleset array_api_ruleset) +(rewrite (TupleNDArray_length (TupleNDArray___add__ ti ti2)) (Int___add__ (TupleNDArray_length ti) (TupleNDArray_length ti2)) :ruleset array_api_ruleset) +(sort UnstableFn_Value_TupleInt (UnstableFn (TupleInt) Value)) +(function NDArray___init__ (TupleInt DType UnstableFn_Value_TupleInt) NDArray) +(rewrite (NDArray_shape (NDArray___init__ shape dtype idx_fn)) shape :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (NDArray___init__ shape dtype idx_fn)) dtype :ruleset array_api_ruleset) +(rewrite (NDArray_ndim x) (TupleInt_length (NDArray_shape x)) :ruleset array_api_ruleset) +(function NDArray_to_value (NDArray) Value) +(rewrite (NDArray_to_value x) (NDArray_index x (TupleInt_EMPTY)) :ruleset array_api_ruleset) +(rewrite (NDArray___truediv__ (NDArray_scalar (Value_float f)) (NDArray_scalar (Value_float f))) (NDArray_scalar (Value_float (Float___init__ 1.0))) :ruleset array_api_ruleset) +(function NDArray___sub__ (NDArray NDArray) NDArray) +(rewrite (NDArray___sub__ (NDArray_scalar (Value_float f)) (NDArray_scalar (Value_float f))) (NDArray_scalar (Value_float (Float___init__ 0.0))) :ruleset array_api_ruleset) +(function NDArray___gt__ (NDArray NDArray) NDArray) +(rewrite (NDArray___gt__ (NDArray_scalar (Value_float (Float___init__ fi1))) (NDArray_scalar (Value_float (Float___init__ fi2)))) (NDArray_scalar (Value_bool (TRUE))) :when ((> fi1 fi2)) :ruleset array_api_ruleset) +(rewrite (NDArray___gt__ (NDArray_scalar (Value_float (Float___init__ fi1))) (NDArray_scalar (Value_float (Float___init__ fi2)))) (NDArray_scalar (Value_bool (FALSE))) :when ((<= fi1 fi2)) :ruleset array_api_ruleset) +(function NDArray_T (NDArray) NDArray) +(rewrite (NDArray_T (NDArray_T x)) x :ruleset array_api_ruleset) +(function TupleValue___add__ (TupleValue TupleValue) TupleValue) +(function TupleValue_EMPTY () TupleValue) +(rewrite (TupleValue___add__ ti (TupleValue_EMPTY)) ti :ruleset array_api_ruleset) +(rewrite (TupleValue_length (TupleValue_EMPTY)) (Int___init__ 0) :ruleset array_api_ruleset) +(rewrite (TupleValue_length (TupleValue___init__ v)) (Int___init__ 1) :ruleset array_api_ruleset) +(rewrite (TupleValue_length (TupleValue___add__ ti ti2)) (Int___add__ (TupleValue_length ti) (TupleValue_length ti2)) :ruleset array_api_ruleset) +(rewrite (TupleValue___getitem__ (TupleValue___init__ v) (Int___init__ 0)) v :ruleset array_api_ruleset) +(rewrite (TupleValue___getitem__ (TupleValue___add__ (TupleValue___init__ v) ti) (Int___init__ 0)) v :ruleset array_api_ruleset) +(rule ((= v (TupleValue___getitem__ (TupleValue___add__ (TupleValue___init__ v2) ti) (Int___init__ k))) + (> k 0)) + ((union v (TupleValue___getitem__ ti (Int___init__ (- k 1))))) + :ruleset array_api_ruleset ) +(rewrite (TupleValue_includes (TupleValue_EMPTY) v) (FALSE) :ruleset array_api_ruleset) +(rewrite (TupleValue_includes (TupleValue___init__ v) v) (TRUE) :ruleset array_api_ruleset) +(rewrite (TupleValue_includes (TupleValue___init__ v) v2) (FALSE) :when ((!= v v2)) :ruleset array_api_ruleset) +(rewrite (TupleValue_includes (TupleValue___add__ ti ti2) v) (Boolean___or__ (TupleValue_includes ti v) (TupleValue_includes ti2 v)) :ruleset array_api_ruleset) +(function DType_int64 () DType) +(rewrite (Value_dtype (Value_int i)) (DType_int64) :ruleset array_api_ruleset) +(rewrite (Value_dtype (Value_float f)) %__expr_2565664028803046192 :ruleset array_api_ruleset) +(function DType_bool () DType) +(rewrite (Value_dtype (Value_bool b)) (DType_bool) :ruleset array_api_ruleset) +(function Value_to_bool (Value) Boolean) +(rewrite (Value_to_bool (Value_bool b)) b :ruleset array_api_ruleset) +(function Value_to_int (Value) Int) +(rewrite (Value_to_int (Value_int i)) i :ruleset array_api_ruleset) +(rewrite (Value_to_truthy_value (Value_bool b)) (Value_bool b) :ruleset array_api_ruleset) +(sort IsDtypeKind) +(function isdtype (DType IsDtypeKind) Boolean) +(function DType_float32 () DType) +(function IsDtypeKind_string (String) IsDtypeKind) +(rewrite (isdtype (DType_float32) (IsDtypeKind_string "integral")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype %__expr_2565664028803046192 (IsDtypeKind_string "integral")) (FALSE) :ruleset array_api_ruleset) +(function DType_object () DType) +(rewrite (isdtype (DType_object) (IsDtypeKind_string "integral")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int64) (IsDtypeKind_string "integral")) (TRUE) :ruleset array_api_ruleset) +(function DType_int32 () DType) +(rewrite (isdtype (DType_int32) (IsDtypeKind_string "integral")) (TRUE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float32) (IsDtypeKind_string "real floating")) (TRUE) :ruleset array_api_ruleset) +(rewrite (isdtype %__expr_2565664028803046192 (IsDtypeKind_string "real floating")) (TRUE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_object) (IsDtypeKind_string "real floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int64) (IsDtypeKind_string "real floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int32) (IsDtypeKind_string "real floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float32) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype %__expr_2565664028803046192 (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_object) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int64) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int32) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(function IsDtypeKind_NULL () IsDtypeKind) +(rewrite (isdtype d (IsDtypeKind_NULL)) (FALSE) :ruleset array_api_ruleset) +(function IsDtypeKind_dtype (DType) IsDtypeKind) +(rewrite (isdtype d (IsDtypeKind_dtype d)) (TRUE) :ruleset array_api_ruleset) +(function IsDtypeKind___or__ (IsDtypeKind IsDtypeKind) IsDtypeKind :cost 10) +(rewrite (isdtype d (IsDtypeKind___or__ k1 k2)) (Boolean___or__ (isdtype d k1) (isdtype d k2)) :ruleset array_api_ruleset) +(rewrite (IsDtypeKind___or__ k1 (IsDtypeKind_NULL)) k1 :ruleset array_api_ruleset) +(rewrite (DType___eq__ %__expr_2565664028803046192 %__expr_2565664028803046192) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ %__expr_2565664028803046192 (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ %__expr_2565664028803046192 (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ %__expr_2565664028803046192 (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ %__expr_2565664028803046192 (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) %__expr_2565664028803046192) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_float32)) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) %__expr_2565664028803046192) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_int32)) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) %__expr_2565664028803046192) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_int64)) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) %__expr_2565664028803046192) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_object)) (TRUE) :ruleset array_api_ruleset) +(function idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___ (UnstableFn_Int_Int Int) Int) +(rewrite (idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___ idx_fn i) (unstable-app idx_fn (Int___add__ i (Int___init__ 1))) :ruleset array_api_ruleset) +(rewrite (TupleInt_length (TupleInt___init__ i idx_fn)) i :ruleset array_api_ruleset) +(rewrite (TupleInt___getitem__ (TupleInt___init__ i idx_fn) i2) (unstable-app idx_fn i2) :ruleset array_api_ruleset) +(rewrite (index_vec_int vs (Int___init__ k)) (vec-get vs k) :when ((> (vec-length vs) k)) :ruleset array_api_ruleset) +(rewrite (TupleInt_fold (TupleInt___init__ (Int___init__ 0) idx_fn) i f) i :ruleset array_api_ruleset) +(rewrite (TupleInt_fold (TupleInt___init__ (Int___init__ k) idx_fn) i f) (unstable-app f (TupleInt_fold (TupleInt___init__ (Int___init__ (- k 1)) (unstable-fn "idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___" idx_fn)) i f) (unstable-app idx_fn (Int___init__ 0))) :when ((!= k 0)) :ruleset array_api_ruleset) +(rewrite (TupleInt_fold_boolean (TupleInt___init__ (Int___init__ 0) idx_fn) b bool_f) b :ruleset array_api_ruleset) +(rewrite (TupleInt_fold_boolean (TupleInt___init__ (Int___init__ k) idx_fn) b bool_f) (unstable-app bool_f (TupleInt_fold_boolean (TupleInt___init__ (Int___init__ (- k 1)) (unstable-fn "idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___" idx_fn)) b bool_f) (unstable-app idx_fn (Int___init__ 0))) :when ((!= k 0)) :ruleset array_api_ruleset) +(sort UnstableFn_Boolean_Int (UnstableFn (Int) Boolean)) +(function TupleInt_filter (TupleInt UnstableFn_Boolean_Int) TupleInt :cost 100) +(rewrite (TupleInt_filter (TupleInt___init__ (Int___init__ 0) idx_fn) filter_f) (TupleInt___init__ (Int___init__ 0) idx_fn) :ruleset array_api_ruleset) +(function TupleInt_if_ (Boolean TupleInt TupleInt) TupleInt) +(rewrite (TupleInt_filter (TupleInt___init__ (Int___init__ k) idx_fn) filter_f) (TupleInt_if_ (unstable-app filter_f (unstable-app idx_fn (Int___init__ k))) (TupleInt___add__ (TupleInt_single (unstable-app idx_fn (Int___init__ k))) (TupleInt_filter (TupleInt___init__ (Int___init__ (- k 1)) (unstable-fn "idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___" idx_fn)) filter_f)) (TupleInt_filter (TupleInt___init__ (Int___init__ (- k 1)) (unstable-fn "idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___" idx_fn)) filter_f)) :when ((!= k 0)) :ruleset array_api_ruleset) +(function bottom_indexing (Int) Int) +(rewrite (TupleInt_EMPTY) (TupleInt___init__ (Int___init__ 0) (unstable-fn "bottom_indexing")) :ruleset array_api_ruleset) +(rewrite (TupleInt_if_ (TRUE) ti ti2) ti :ruleset array_api_ruleset) +(rewrite (TupleInt_if_ (FALSE) ti ti2) ti2 :ruleset array_api_ruleset) +(rewrite (Float_abs (Float___init__ f)) (Float___init__ f) :when ((>= f 0.0)) :ruleset array_api_ruleset) +(rewrite (Float_abs (Float___init__ f)) (Float___init__ (neg f)) :when ((< f 0.0)) :ruleset array_api_ruleset) +(function Float_rational (Rational) Float :cost 2) +(rewrite (Float___init__ f) (Float_rational (rational (to-i64 f) 1)) :when ((= (to-f64 (to-i64 f)) f)) :ruleset array_api_ruleset) +(function Float_from_int (Int) Float) +(rewrite (Float_from_int (Int___init__ i)) (Float_rational (rational i 1)) :ruleset array_api_ruleset) +(function Float___add__ (Float Float) Float) +(rewrite (Float___add__ (Float___init__ f) (Float___init__ f2)) (Float___init__ (+ f f2)) :ruleset array_api_ruleset) +(function Float___sub__ (Float Float) Float) +(rewrite (Float___sub__ (Float___init__ f) (Float___init__ f2)) (Float___init__ (- f f2)) :ruleset array_api_ruleset) +(function Float___mul__ (Float Float) Float) +(rewrite (Float___mul__ (Float___init__ f) (Float___init__ f2)) (Float___init__ (* f f2)) :ruleset array_api_ruleset) +(function Float___truediv__ (Float Float) Float) +(rewrite (Float___truediv__ (Float_rational r) (Float_rational r1)) (Float_rational (/ r r1)) :ruleset array_api_ruleset) +(rewrite (Float___add__ (Float_rational r) (Float_rational r1)) (Float_rational (+ r r1)) :ruleset array_api_ruleset) +(rewrite (Float___sub__ (Float_rational r) (Float_rational r1)) (Float_rational (- r r1)) :ruleset array_api_ruleset) +(rewrite (Float___mul__ (Float_rational r) (Float_rational r1)) (Float_rational (* r r1)) :ruleset array_api_ruleset) +(rewrite (Int___eq__ (Int___init__ i) (Int___init__ i)) (TRUE) :ruleset array_api_ruleset) +(rule ((= r (Int___eq__ (Int___init__ i) (Int___init__ j))) + (!= i j)) + ((union r (FALSE))) + :ruleset array_api_ruleset ) +(function Int___ge__ (Int Int) Boolean) +(rewrite (Int___ge__ (Int___init__ i) (Int___init__ i)) (TRUE) :ruleset array_api_ruleset) +(rule ((= r (Int___ge__ (Int___init__ i) (Int___init__ j))) + (> i j)) + ((union r (TRUE))) + :ruleset array_api_ruleset ) +(rule ((= r (Int___ge__ (Int___init__ i) (Int___init__ j))) + (< i j)) + ((union r (FALSE))) + :ruleset array_api_ruleset ) +(rewrite (Int___lt__ (Int___init__ i) (Int___init__ i)) (FALSE) :ruleset array_api_ruleset) +(rule ((= r (Int___lt__ (Int___init__ i) (Int___init__ j))) + (< i j)) + ((union r (TRUE))) + :ruleset array_api_ruleset ) +(rule ((= r (Int___lt__ (Int___init__ i) (Int___init__ j))) + (> i j)) + ((union r (FALSE))) + :ruleset array_api_ruleset ) +(function Int___gt__ (Int Int) Boolean) +(rewrite (Int___gt__ (Int___init__ i) (Int___init__ i)) (FALSE) :ruleset array_api_ruleset) +(rule ((= r (Int___gt__ (Int___init__ i) (Int___init__ j))) + (> i j)) + ((union r (TRUE))) + :ruleset array_api_ruleset ) +(rule ((= r (Int___gt__ (Int___init__ i) (Int___init__ j))) + (< i j)) + ((union r (FALSE))) + :ruleset array_api_ruleset ) +(function Int_i64 (Int) i64) +(rule ((= o (Int___init__ j))) + ((set (Int_i64 o) j)) + :ruleset array_api_ruleset ) +(rewrite (Int___add__ (Int___init__ i) (Int___init__ j)) (Int___init__ (+ i j)) :ruleset array_api_ruleset) +(rewrite (Int___sub__ (Int___init__ i) (Int___init__ j)) (Int___init__ (- i j)) :ruleset array_api_ruleset) +(rewrite (Int___mul__ (Int___init__ i) (Int___init__ j)) (Int___init__ (* i j)) :ruleset array_api_ruleset) +(function Int___truediv__ (Int Int) Int) +(rewrite (Int___truediv__ (Int___init__ i) (Int___init__ j)) (Int___init__ (/ i j)) :ruleset array_api_ruleset) +(function Int___mod__ (Int Int) Int) +(rewrite (Int___mod__ (Int___init__ i) (Int___init__ j)) (Int___init__ (% i j)) :ruleset array_api_ruleset) +(function Int___and__ (Int Int) Int) +(rewrite (Int___and__ (Int___init__ i) (Int___init__ j)) (Int___init__ (& i j)) :ruleset array_api_ruleset) +(function Int___or__ (Int Int) Int) +(rewrite (Int___or__ (Int___init__ i) (Int___init__ j)) (Int___init__ (| i j)) :ruleset array_api_ruleset) +(function Int___xor__ (Int Int) Int) +(rewrite (Int___xor__ (Int___init__ i) (Int___init__ j)) (Int___init__ (^ i j)) :ruleset array_api_ruleset) +(function Int___lshift__ (Int Int) Int) +(rewrite (Int___lshift__ (Int___init__ i) (Int___init__ j)) (Int___init__ (<< i j)) :ruleset array_api_ruleset) +(function Int___rshift__ (Int Int) Int) +(rewrite (Int___rshift__ (Int___init__ i) (Int___init__ j)) (Int___init__ (>> i j)) :ruleset array_api_ruleset) +(function Int___invert__ (Int) Int) +(rewrite (Int___invert__ (Int___init__ i)) (Int___init__ (not-i64 i)) :ruleset array_api_ruleset) +(rewrite (Int_if_ (TRUE) o b) o :ruleset array_api_ruleset) +(rewrite (Int_if_ (FALSE) o b) b :ruleset array_api_ruleset) +(function Boolean_bool (Boolean) bool) +(rule ((= x (TRUE))) + ((set (Boolean_bool x) true)) + :ruleset array_api_ruleset ) +(rule ((= x (FALSE))) + ((set (Boolean_bool x) false)) + :ruleset array_api_ruleset ) +(rewrite (Boolean___or__ (TRUE) x) (TRUE) :ruleset array_api_ruleset) +(rewrite (Boolean___or__ (FALSE) x) x :ruleset array_api_ruleset) +(function Boolean___and__ (Boolean Boolean) Boolean) +(rewrite (Boolean___and__ (TRUE) x) x :ruleset array_api_ruleset) +(rewrite (Boolean___and__ (FALSE) x) (FALSE) :ruleset array_api_ruleset) +(function Boolean_if_int (Boolean Int Int) Int) +(rewrite (Boolean_if_int (TRUE) i j) i :ruleset array_api_ruleset) +(rewrite (Boolean_if_int (FALSE) i j) j :ruleset array_api_ruleset) +(function Boolean___invert__ (Boolean) Boolean) +(rewrite (Boolean___invert__ (TRUE)) (FALSE) :ruleset array_api_ruleset) +(rewrite (Boolean___invert__ (FALSE)) (TRUE) :ruleset array_api_ruleset) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (DType___eq__ %__expr_2565664028803046192 (NDArray_dtype (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4)))))))) 0) +(Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) 0) +(Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1))) 0) +(Int___ge__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 3)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___ge__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 3))) 0) +(isdtype (NDArray_dtype (asarray (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (IsDtypeKind___or__ (IsDtypeKind_string "real floating") (IsDtypeKind___or__ (IsDtypeKind_string "complex floating") (IsDtypeKind_NULL)))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (isdtype (NDArray_dtype (asarray (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (IsDtypeKind___or__ (IsDtypeKind_string "real floating") (IsDtypeKind___or__ (IsDtypeKind_string "complex floating") (IsDtypeKind_NULL))))) 0) +(let %__expr_-3674731718720096444 (OptionalDevice_none)) +(Value_to_bool (NDArray_to_value (isfinite (sum (asarray (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalIntOrTuple_none))))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Value_to_bool (NDArray_to_value (isfinite (sum (asarray (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalIntOrTuple_none)))))) 0) +(TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) 0) +(Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (Int___init__ 2)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (Int___init__ 2))) 0) +(Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 2)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 2))) 0) +(Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (Int___init__ 1)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (Int___init__ 1))) 0) +(Int___ge__ (NDArray_ndim (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444)) (Int___init__ 3)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___ge__ (NDArray_ndim (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444)) (Int___init__ 3))) 0) +(let %__expr_2305922367412063525 (Int___init__ 2)) +(Int___eq__ (NDArray_ndim (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444)) %__expr_2305922367412063525) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (NDArray_ndim (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444)) %__expr_2305922367412063525)) 0) +(TupleInt_length (NDArray_shape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt_length (NDArray_shape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444)))) 0) +(let %__expr_2091604061025500396 (OptionalDType_none)) +(let %__expr_-4122594143565222517 (OptionalBool_none)) +(isdtype (NDArray_dtype (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (IsDtypeKind___or__ (IsDtypeKind_string "real floating") (IsDtypeKind___or__ (IsDtypeKind_string "complex floating") (IsDtypeKind_NULL)))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (isdtype (NDArray_dtype (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (IsDtypeKind___or__ (IsDtypeKind_string "real floating") (IsDtypeKind___or__ (IsDtypeKind_string "complex floating") (IsDtypeKind_NULL))))) 0) +(TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) 0) +(TupleInt_length (NDArray_shape (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt_length (NDArray_shape (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)))) 0) +(let %__expr_-7942988945600443502 (Int___init__ 0)) +(Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)))) 0) +(let %__expr_-3520630818915629594 (Int___init__ 150)) +(Int___gt__ (TupleInt___getitem__ (NDArray_shape (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___gt__ (TupleInt___getitem__ (NDArray_shape (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)))) 0) +(Int___eq__ (TupleInt___getitem__ (NDArray_shape (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (TupleInt___getitem__ (NDArray_shape (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)))) 0) +(TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) 0) +(Int___eq__ (NDArray_ndim (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_2305922367412063525) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (NDArray_ndim (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_2305922367412063525)) 0) +(let %__expr_3300329792522185471 (Int___init__ 1)) +(Int___eq__ (NDArray_ndim (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_3300329792522185471) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (NDArray_ndim (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_3300329792522185471)) 0) +(TupleInt_length (NDArray_shape (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt_length (NDArray_shape (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)))) 0) +(TupleInt___getitem__ (NDArray_shape (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt___getitem__ (NDArray_shape (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502)) 0) +(DType___eq__ (NDArray_dtype (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (DType_object)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (DType___eq__ (NDArray_dtype (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (DType_object))) 0) +(Int___eq__ (NDArray_ndim (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_2305922367412063525) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (NDArray_ndim (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_2305922367412063525)) 0) +(isdtype (NDArray_dtype (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (IsDtypeKind_string "real floating")) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (isdtype (NDArray_dtype (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (IsDtypeKind_string "real floating"))) 0) +(Int___gt__ (TupleInt___getitem__ (NDArray_shape (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) %__expr_-7942988945600443502) %__expr_2305922367412063525) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___gt__ (TupleInt___getitem__ (NDArray_shape (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) %__expr_-7942988945600443502) %__expr_2305922367412063525)) 0) +(TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) 0) +(Int___eq__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502))) 0) +(TupleNDArray_length (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleNDArray_length (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)))) 0) +(TupleInt___getitem__ (NDArray_shape (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt___getitem__ (NDArray_shape (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502)) 0) +(let %__expr_478758938070675600 (Value_int (Int___init__ 0))) +(Value_to_bool (NDArray_to_value (any (NDArray___lt__ (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_3300329792522185471) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0)))) (NDArray_scalar %__expr_478758938070675600))))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Value_to_bool (NDArray_to_value (any (NDArray___lt__ (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_3300329792522185471) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0)))) (NDArray_scalar %__expr_478758938070675600)))))) 0) +(Value_to_bool (NDArray_to_value (NDArray___gt__ (ndarray-abs (NDArray___sub__ (sum (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_3300329792522185471) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0)))) (OptionalIntOrTuple_none)) (NDArray_scalar (Value_float (Float___init__ 1.0))))) (NDArray_scalar (Value_float (Float___init__ 0.00001)))))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Value_to_bool (NDArray_to_value (NDArray___gt__ (ndarray-abs (NDArray___sub__ (sum (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_3300329792522185471) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0)))) (OptionalIntOrTuple_none)) (NDArray_scalar (Value_float (Float___init__ 1.0))))) (NDArray_scalar (Value_float (Float___init__ 0.00001))))))) 0) +(Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (Int___sub__ (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502) %__expr_3300329792522185471)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (Int___sub__ (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502) %__expr_3300329792522185471))) 0) +(Int___lt__ (Int___sub__ (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502) %__expr_3300329792522185471) %__expr_2305922367412063525) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___lt__ (Int___sub__ (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502) %__expr_3300329792522185471) %__expr_2305922367412063525)) 0) +(TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) 0) +(TupleNDArray_length (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleNDArray_length (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)))) 0) +(TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502)) %__expr_-7942988945600443502) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502)) %__expr_-7942988945600443502)) 0) +(NDArray_size (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (NDArray_size (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none))))) 0) +(let %__expr_-8664633617851008504 (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) +(let %__expr_-8475266842302933511 (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) +(let %__expr_-6765600943420531488 (Value_int (Int___init__ 2))) +(let %__expr_-5200143055942215294 (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) +(let %__expr_-8613124149453883591 (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) +(let %__expr_-622493510873225930 (Value_int (Int___init__ 1))) +(let %__expr_-3283806677371465170 (NDArray_scalar %__expr_478758938070675600)) +(let %__expr_-2704792733181451377 (TupleNDArray___getitem__ %__expr_-8664633617851008504 %__expr_3300329792522185471)) +(sort MultiAxisIndexKeyItem) +(sort Slice) +(function MultiAxisIndexKeyItem_slice (Slice) MultiAxisIndexKeyItem) +(function Slice___init__ (OptionalInt OptionalInt OptionalInt) Slice) +(let %__expr_-8637348939342624324 (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))) +(sort IntOrTuple) +(function OptionalIntOrTuple_some (IntOrTuple) OptionalIntOrTuple) +(function IntOrTuple_int (Int) IntOrTuple) +(let %__expr_1913846200346632608 (OptionalIntOrTuple_some (IntOrTuple_int %__expr_-7942988945600443502))) +(let %__expr_6185990579165616281 (FALSE)) +(let %__expr_-1113027338580586528 (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) +(sort MultiAxisIndexKey) +(function IndexKey_multi_axis (MultiAxisIndexKey) IndexKey) +(sort Vec_MultiAxisIndexKeyItem (Vec MultiAxisIndexKeyItem)) +(function MultiAxisIndexKey_from_vec (Vec_MultiAxisIndexKeyItem) MultiAxisIndexKey) +(function MultiAxisIndexKeyItem_int (Int) MultiAxisIndexKeyItem) +(let %__expr_7180621784385959982 (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_3300329792522185471) %__expr_-8637348939342624324)))) +(let %__expr_-4323225966908438009 (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_-7942988945600443502) %__expr_-8637348939342624324)))) +(let %__expr_483064111004974365 (Float___init__ 1.0)) +(let %__expr_-143818766793636568 (OptionalInt_none)) +(function NDArray___setitem__ (NDArray IndexKey NDArray) NDArray) +(function zeros (TupleInt OptionalDType OptionalDevice) NDArray) +(function OptionalDType_some (DType) OptionalDType) +(sort Device) +(function OptionalDevice_some (Device) OptionalDevice) +(function NDArray_device (NDArray) Device) +(function mean (NDArray OptionalIntOrTuple Boolean) NDArray) +(function IndexKey_ndarray (NDArray) IndexKey) +(function NDArray___eq__ (NDArray NDArray) NDArray) +(let %__expr_7843526591494960327 (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502)) %__expr_-7942988945600443502) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device %__expr_-8613124149453883591))) %__expr_-4323225966908438009 (mean (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-2704792733181451377 %__expr_-3283806677371465170))) %__expr_1913846200346632608 %__expr_6185990579165616281)) %__expr_7180621784385959982 (mean (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-2704792733181451377 (NDArray_scalar %__expr_-622493510873225930)))) %__expr_1913846200346632608 %__expr_6185990579165616281)) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_2305922367412063525) %__expr_-8637348939342624324))) (mean (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-2704792733181451377 (NDArray_scalar %__expr_-6765600943420531488)))) %__expr_1913846200346632608 %__expr_6185990579165616281))) +(let %__expr_-954298076671303615 (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_2305922367412063525) %__expr_-8637348939342624324)))) +(function std (NDArray OptionalIntOrTuple) NDArray) +(function OptionalInt_some (Int) OptionalInt) +(let %__expr_3049932803880609425 (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 (IndexKey_int %__expr_-7942988945600443502))))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_-4323225966908438009))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 (IndexKey_int %__expr_3300329792522185471))))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_7180621784385959982))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 (IndexKey_int %__expr_2305922367412063525))))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_-954298076671303615))))) (OptionalInt_some %__expr_-7942988945600443502)) %__expr_1913846200346632608)) +(let %__expr_-671931098406187877 (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 (IndexKey_int %__expr_-7942988945600443502))))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_-4323225966908438009))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 (IndexKey_int %__expr_3300329792522185471))))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_7180621784385959982))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 (IndexKey_int %__expr_2305922367412063525))))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_-954298076671303615))))) (OptionalInt_some %__expr_-7942988945600443502))) +(function NDArray___mul__ (NDArray NDArray) NDArray) +(function ndarray-sqrt (NDArray) NDArray) +(TupleNDArray_length (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502)))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (NDArray___truediv__ %__expr_-671931098406187877 (NDArray___setitem__ %__expr_3049932803880609425 (IndexKey_ndarray (NDArray___eq__ %__expr_3049932803880609425 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) %__expr_6185990579165616281)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleNDArray_length (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502)))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (NDArray___truediv__ %__expr_-671931098406187877 (NDArray___setitem__ %__expr_3049932803880609425 (IndexKey_ndarray (NDArray___eq__ %__expr_3049932803880609425 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) %__expr_6185990579165616281))) 0) +(Int___eq__ (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502) %__expr_3300329792522185471) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502) %__expr_3300329792522185471)) 0) +(let %__expr_-1459297673498492435 (Slice___init__ %__expr_-143818766793636568 (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502)))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (NDArray___truediv__ %__expr_-671931098406187877 (NDArray___setitem__ %__expr_3049932803880609425 (IndexKey_ndarray (NDArray___eq__ %__expr_3049932803880609425 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) %__expr_6185990579165616281) %__expr_3300329792522185471) (NDArray_scalar (Value_float (Float___init__ 0.0001)))) (DType_int32)) (OptionalIntOrTuple_none))))) %__expr_-143818766793636568)) +(let %__expr_-5540247018246576406 (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_3300329792522185471) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0))))) +(let %__expr_-4744074158064860754 (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502)))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (NDArray___truediv__ %__expr_-671931098406187877 (NDArray___setitem__ %__expr_3049932803880609425 (IndexKey_ndarray (NDArray___eq__ %__expr_3049932803880609425 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) %__expr_6185990579165616281) %__expr_3300329792522185471)) +(let %__expr_2307122782736907488 (NDArray___setitem__ %__expr_3049932803880609425 (IndexKey_ndarray (NDArray___eq__ %__expr_3049932803880609425 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float___init__ 1.0))))) +(let %__expr_4799320818084596281 (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502)))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (NDArray___truediv__ %__expr_-671931098406187877 (NDArray___setitem__ %__expr_3049932803880609425 (IndexKey_ndarray (NDArray___eq__ %__expr_3049932803880609425 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) %__expr_6185990579165616281)) +(function NDArray___matmul__ (NDArray NDArray) NDArray) +(function IndexKey_slice (Slice) IndexKey) +(TupleNDArray_length (svd (NDArray___matmul__ (NDArray_T (NDArray___mul__ (ndarray-sqrt (NDArray___mul__ (NDArray___mul__ (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)))) %__expr_-5540247018246576406) (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502) %__expr_3300329792522185471))))))) (NDArray_T (NDArray___sub__ %__expr_7843526591494960327 (NDArray___matmul__ %__expr_-5540247018246576406 %__expr_7843526591494960327))))) (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ %__expr_4799320818084596281 %__expr_2305922367412063525) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice %__expr_-1459297673498492435) %__expr_-8637348939342624324)))) %__expr_2307122782736907488)) (NDArray___getitem__ %__expr_-4744074158064860754 (IndexKey_slice %__expr_-1459297673498492435)))) %__expr_6185990579165616281)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleNDArray_length (svd (NDArray___matmul__ (NDArray_T (NDArray___mul__ (ndarray-sqrt (NDArray___mul__ (NDArray___mul__ (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)))) %__expr_-5540247018246576406) (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502) %__expr_3300329792522185471))))))) (NDArray_T (NDArray___sub__ %__expr_7843526591494960327 (NDArray___matmul__ %__expr_-5540247018246576406 %__expr_7843526591494960327))))) (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ %__expr_4799320818084596281 %__expr_2305922367412063525) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice %__expr_-1459297673498492435) %__expr_-8637348939342624324)))) %__expr_2307122782736907488)) (NDArray___getitem__ %__expr_-4744074158064860754 (IndexKey_slice %__expr_-1459297673498492435)))) %__expr_6185990579165616281))) 0) +(TupleInt_length (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none))))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt_length (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))))) 0) +(Int___eq__ (Int___mul__ %__expr_3300329792522185471 (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502)) %__expr_2305922367412063525) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (Int___mul__ %__expr_3300329792522185471 (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502)) %__expr_2305922367412063525)) 0) +(Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) 0) +(Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1))) 0) +(Int___ge__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 3)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___ge__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 3))) 0) +(isdtype (NDArray_dtype (asarray (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (IsDtypeKind___or__ (IsDtypeKind_string "real floating") (IsDtypeKind___or__ (IsDtypeKind_string "complex floating") (IsDtypeKind_NULL)))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (isdtype (NDArray_dtype (asarray (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (IsDtypeKind___or__ (IsDtypeKind_string "real floating") (IsDtypeKind___or__ (IsDtypeKind_string "complex floating") (IsDtypeKind_NULL))))) 0) +(Value_to_bool (NDArray_to_value (isfinite (sum (asarray (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalIntOrTuple_none))))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Value_to_bool (NDArray_to_value (isfinite (sum (asarray (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalIntOrTuple_none)))))) 0) +(TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt_length (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) 0) +(Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) %__expr_3300329792522185471) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) %__expr_3300329792522185471)) 0) +(Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 2)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (NDArray_ndim (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 2))) 0) +(Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (Int___init__ 1)) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___lt__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (Int___init__ 1))) 0) +(TupleInt_length (NDArray_shape (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Int_i64 (TupleInt_length (NDArray_shape (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4)))))))) 0) +(let %__expr_-7766708656681124433 (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4)))))) +(Int___eq__ (TupleInt___getitem__ (NDArray_shape (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4)))))) %__expr_3300329792522185471) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1))) +(run-schedule (saturate (run array_api_ruleset))) +(extract (Boolean_bool (Int___eq__ (TupleInt___getitem__ (NDArray_shape (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4)))))) %__expr_3300329792522185471) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") %__expr_2565664028803046192) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) 0) +(pop 1) +(ruleset array_api_ruleset) +(sort Int) +(function i-Int__-Int_i (Int Int) Int) +(rewrite (i-Int__-Int_i i _) i :ruleset array_api_ruleset) +(sort TupleInt) +(function TupleInt_single (Int) TupleInt) +(sort UnstableFn_Int_Int (UnstableFn (Int) Int)) +(function TupleInt___init__ (Int UnstableFn_Int_Int) TupleInt :unextractable) +(function Int___init__ (i64) Int) +(rewrite (TupleInt_single i) (TupleInt___init__ (Int___init__ 1) (unstable-fn "i-Int__-Int_i" i)) :ruleset array_api_ruleset) +(function i-Int_i (Int) Int) +(rewrite (i-Int_i i) i :ruleset array_api_ruleset) +(function TupleInt_range (Int) TupleInt) +(rewrite (TupleInt_range stop) (TupleInt___init__ stop (unstable-fn "i-Int_i")) :ruleset array_api_ruleset) +(sort Vec_Int (Vec Int)) +(function TupleInt_from_vec (Vec_Int) TupleInt) +(function index_vec_int (Vec_Int Int) Int) +(rewrite (TupleInt_from_vec vec) (TupleInt___init__ (Int___init__ (vec-length vec)) (unstable-fn "index_vec_int" vec)) :ruleset array_api_ruleset) +(sort Boolean) +(function Int_if_ (Boolean Int Int) Int) +(function Int___lt__ (Int Int) Boolean) +(function TupleInt_length (TupleInt) Int) +(function TupleInt___getitem__ (TupleInt Int) Int) +(function Int___sub__ (Int Int) Int) +(function other-TupleInt_self-TupleInt_i-Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____ (TupleInt TupleInt Int) Int) +(rewrite (other-TupleInt_self-TupleInt_i-Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____ other self i) (Int_if_ (Int___lt__ i (TupleInt_length self)) (TupleInt___getitem__ self i) (TupleInt___getitem__ other (Int___sub__ i (TupleInt_length self)))) :ruleset array_api_ruleset) +(function TupleInt___add__ (TupleInt TupleInt) TupleInt) +(function Int___add__ (Int Int) Int) +(rewrite (TupleInt___add__ self other) (TupleInt___init__ (Int___add__ (TupleInt_length self) (TupleInt_length other)) (unstable-fn "other-TupleInt_self-TupleInt_i-Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____" other self)) :ruleset array_api_ruleset) +(function Boolean___or__ (Boolean Boolean) Boolean) +(function Int___eq__ (Int Int) Boolean) +(function i-Int_acc-Boolean_j-Int__Boolean___or___acc__Int___eq___i_j__ (Int Boolean Int) Boolean) +(rewrite (i-Int_acc-Boolean_j-Int__Boolean___or___acc__Int___eq___i_j__ i acc j) (Boolean___or__ acc (Int___eq__ i j)) :ruleset array_api_ruleset) +(function TupleInt_contains (TupleInt Int) Boolean) +(sort UnstableFn_Boolean_Boolean_Int (UnstableFn (Boolean Int) Boolean)) +(function TupleInt_fold_boolean (TupleInt Boolean UnstableFn_Boolean_Boolean_Int) Boolean) +(function FALSE () Boolean) +(rewrite (TupleInt_contains self i) (TupleInt_fold_boolean self (FALSE) (unstable-fn "i-Int_acc-Boolean_j-Int__Boolean___or___acc__Int___eq___i_j__" i)) :ruleset array_api_ruleset) +(function f-UnstableFn_Int_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__ (UnstableFn_Int_Int TupleInt Int) Int) +(rewrite (f-UnstableFn_Int_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__ f self i) (unstable-app f (TupleInt___getitem__ self i)) :ruleset array_api_ruleset) +(function TupleInt_map (TupleInt UnstableFn_Int_Int) TupleInt :cost 100) +(rewrite (TupleInt_map self f) (TupleInt___init__ (TupleInt_length self) (unstable-fn "f-UnstableFn_Int_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__" f self)) :ruleset array_api_ruleset) +(sort NDArray) +(function NDArray_size (NDArray) Int) +(sort UnstableFn_Int_Int_Int (UnstableFn (Int Int) Int)) +(function TupleInt_fold (TupleInt Int UnstableFn_Int_Int_Int) Int) +(function NDArray_shape (NDArray) TupleInt) +(function Int___mul__ (Int Int) Int) +(rewrite (NDArray_size x) (TupleInt_fold (NDArray_shape x) (Int___init__ 1) (unstable-fn "Int___mul__")) :ruleset array_api_ruleset) +(function unique_values (NDArray) NDArray) +(sort TupleValue) +(function NDArray_vector (TupleValue) NDArray) +(sort Value) +(function possible_values (Value) TupleValue) +(function NDArray_index (NDArray TupleInt) Value) +(function ALL_INDICES () TupleInt) +(rewrite (unique_values a) (NDArray_vector (possible_values (NDArray_index a (ALL_INDICES)))) :ruleset array_api_ruleset) +(function Value_isfinite (Value) Boolean) +(function Value_int (Int) Value) +(function TRUE () Boolean) +(rewrite (Value_isfinite (Value_int i)) (TRUE) :ruleset array_api_ruleset) +(function Value_bool (Boolean) Value) +(rewrite (Value_isfinite (Value_bool b)) (TRUE) :ruleset array_api_ruleset) +(sort Float) +(function Value_float (Float) Value) +(function Float___init__ (f64) Float :cost 3) +(rewrite (Value_isfinite (Value_float (Float___init__ f))) (TRUE) :when ((!= f NaN)) :ruleset array_api_ruleset) +(function isfinite (NDArray) NDArray) +(sort OptionalIntOrTuple) +(function sum (NDArray OptionalIntOrTuple) NDArray) +(function OptionalIntOrTuple_none () OptionalIntOrTuple) +(function NDArray_scalar (Value) NDArray) +(rewrite (isfinite (sum arr (OptionalIntOrTuple_none))) (NDArray_scalar (Value_bool (Value_isfinite (NDArray_index arr (ALL_INDICES))))) :ruleset array_api_ruleset) +(function assume_value_one_of (NDArray TupleValue) NDArray) +(rewrite (NDArray_shape (assume_value_one_of x vs)) (NDArray_shape x) :ruleset array_api_ruleset) +(sort DType) +(function NDArray_dtype (NDArray) DType) +(rewrite (NDArray_dtype (assume_value_one_of x vs)) (NDArray_dtype x) :ruleset array_api_ruleset) +(rule ((= v (NDArray_index (assume_value_one_of x vs) idx))) + ((union v (NDArray_index x idx)) + (union (possible_values v) vs)) + :ruleset array_api_ruleset ) +(function assume_isfinite (NDArray) NDArray) +(rewrite (NDArray_shape (assume_isfinite x)) (NDArray_shape x) :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (assume_isfinite x)) (NDArray_dtype x) :ruleset array_api_ruleset) +(rewrite (NDArray_index (assume_isfinite x) ti) (NDArray_index x ti) :ruleset array_api_ruleset) +(rewrite (Value_isfinite (NDArray_index (assume_isfinite x) ti)) (TRUE) :ruleset array_api_ruleset) +(function assume_shape (NDArray TupleInt) NDArray) +(rewrite (NDArray_shape (assume_shape x shape)) shape :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (assume_shape x shape)) (NDArray_dtype x) :ruleset array_api_ruleset) +(rewrite (NDArray_index (assume_shape x shape) idx) (NDArray_index x idx) :ruleset array_api_ruleset) +(function assume_dtype (NDArray DType) NDArray) +(rewrite (NDArray_dtype (assume_dtype x dtype)) dtype :ruleset array_api_ruleset) +(rewrite (NDArray_shape (assume_dtype x dtype)) (NDArray_shape x) :ruleset array_api_ruleset) +(rewrite (NDArray_index (assume_dtype x dtype) idx) (NDArray_index x idx) :ruleset array_api_ruleset) +(sort IndexKey) +(function NDArray___getitem__ (NDArray IndexKey) NDArray) +(function IndexKey_int (Int) IndexKey) +(rewrite (NDArray___getitem__ x (IndexKey_int i)) (NDArray_scalar (NDArray_index x (TupleInt_single i))) :ruleset array_api_ruleset) +(sort OptionalBool) +(function reshape (NDArray TupleInt OptionalBool) NDArray) +(rule ((= __a (reshape x shape copy))) + ((NDArray_shape x) + (TupleInt_length (NDArray_shape x))) + :ruleset array_api_ruleset ) +(rule ((reshape x shape copy)) + ((TupleInt_length shape) + (TupleInt___getitem__ shape (Int___init__ 0))) + :ruleset array_api_ruleset ) +(rewrite (reshape x shape copy) x :when ((= (TupleInt_length (NDArray_shape x)) (Int___init__ 1)) (= (TupleInt_length shape) (Int___init__ 1)) (= (TupleInt___getitem__ shape (Int___init__ 0)) (Int___init__ -1))) :ruleset array_api_ruleset) +(function TupleValue_length (TupleValue) Int) +(rewrite (NDArray_shape (NDArray_vector vs)) (TupleInt_single (TupleValue_length vs)) :ruleset array_api_ruleset) +(function Value_dtype (Value) DType) +(function TupleValue___getitem__ (TupleValue Int) Value) +(rewrite (NDArray_dtype (NDArray_vector vs)) (Value_dtype (TupleValue___getitem__ vs (Int___init__ 0))) :ruleset array_api_ruleset) +(rewrite (NDArray_index (NDArray_vector vs) ti) (TupleValue___getitem__ vs (TupleInt___getitem__ ti (Int___init__ 0))) :ruleset array_api_ruleset) +(function TupleInt_EMPTY () TupleInt) +(rewrite (NDArray_shape (NDArray_scalar v)) (TupleInt_EMPTY) :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (NDArray_scalar v)) (Value_dtype v) :ruleset array_api_ruleset) +(rewrite (NDArray_index (NDArray_scalar v) (TupleInt_EMPTY)) v :ruleset array_api_ruleset) +(function any (NDArray) NDArray) +(function TupleValue_includes (TupleValue Value) Boolean) +(function Value_to_truthy_value (Value) Value) +(rewrite (any x) (NDArray_scalar (Value_bool (TupleValue_includes (possible_values (Value_to_truthy_value (NDArray_index x (ALL_INDICES)))) (Value_bool (TRUE))))) :ruleset array_api_ruleset) +(function NDArray___lt__ (NDArray NDArray) NDArray) +(function Value___lt__ (Value Value) Value) +(function broadcast_index (TupleInt TupleInt TupleInt) TupleInt) +(function broadcast_shapes (TupleInt TupleInt) TupleInt) +(rewrite (NDArray_index (NDArray___lt__ x y) idx) (Value___lt__ (NDArray_index x (broadcast_index (NDArray_shape x) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx)) (NDArray_index y (broadcast_index (NDArray_shape y) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx))) :ruleset array_api_ruleset) +(function NDArray___truediv__ (NDArray NDArray) NDArray) +(function Value___truediv__ (Value Value) Value) +(rewrite (NDArray_index (NDArray___truediv__ x y) idx) (Value___truediv__ (NDArray_index x (broadcast_index (NDArray_shape x) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx)) (NDArray_index y (broadcast_index (NDArray_shape y) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx))) :ruleset array_api_ruleset) +(rewrite (NDArray_index (NDArray_scalar v) idx) v :ruleset array_api_ruleset) +(function astype (NDArray DType) NDArray) +(function Value_astype (Value DType) Value) +(rewrite (NDArray_index (astype x dtype) idx) (Value_astype (NDArray_index x idx) dtype) :ruleset array_api_ruleset) +(relation greater_zero (Value)) +(sort TupleNDArray) +(function TupleNDArray___getitem__ (TupleNDArray Int) NDArray) +(function unique_counts (NDArray) TupleNDArray) +(rule ((= v (NDArray_index (TupleNDArray___getitem__ (unique_counts x) (Int___init__ 1)) idx))) + ((greater_zero v)) + :ruleset array_api_ruleset ) +(rule ((greater_zero v) + (= v1 (Value_astype v dtype))) + ((greater_zero v1)) + :ruleset array_api_ruleset ) +(rule ((= v (Value_float (Float___init__ f))) + (> f 0.0)) + ((greater_zero v)) + :ruleset array_api_ruleset ) +(rule ((= v (Value_int (Int___init__ i))) + (> i 0)) + ((greater_zero v)) + :ruleset array_api_ruleset ) +(rule ((greater_zero v) + (greater_zero v1) + (= v2 (Value___truediv__ v v1))) + ((greater_zero v2)) + :ruleset array_api_ruleset ) +(rule ((greater_zero v) + (= v1 (Value___lt__ v (Value_int (Int___init__ 0))))) + ((union v1 (Value_bool (FALSE)))) + :ruleset array_api_ruleset ) +(function TupleValue___init__ (Value) TupleValue) +(rewrite (possible_values (Value_bool b)) (TupleValue___init__ (Value_bool b)) :ruleset array_api_ruleset) +(rule ((= v1 (Value_astype v dtype)) + (greater_zero v)) + ((greater_zero v1)) + :ruleset array_api_ruleset ) +(function TupleNDArray_length (TupleNDArray) Int) +(function svd (NDArray Boolean) TupleNDArray) +(rewrite (TupleNDArray_length (svd x full_matrices)) (Int___init__ 3) :ruleset array_api_ruleset) +(function unique_inverse (NDArray) TupleNDArray) +(rewrite (TupleNDArray_length (unique_inverse x)) (Int___init__ 2) :ruleset array_api_ruleset) +(rewrite (TupleNDArray___getitem__ (unique_inverse x) (Int___init__ 0)) (unique_values x) :ruleset array_api_ruleset) +(function ndarray-abs (NDArray) NDArray) +(function Float_abs (Float) Float) +(rewrite (ndarray-abs (NDArray_scalar (Value_float f))) (NDArray_scalar (Value_float (Float_abs f))) :ruleset array_api_ruleset) +(rewrite (TupleNDArray_length (unique_counts x)) (Int___init__ 2) :ruleset array_api_ruleset) +(rewrite (sum (TupleNDArray___getitem__ (unique_counts x) (Int___init__ 1)) (OptionalIntOrTuple_none)) (NDArray_scalar (Value_int (NDArray_size x))) :ruleset array_api_ruleset) +(rewrite (sum (astype (TupleNDArray___getitem__ (unique_counts x) (Int___init__ 1)) dtype) (OptionalIntOrTuple_none)) (astype (NDArray_scalar (Value_int (NDArray_size x))) dtype) :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (astype x dtype)) dtype :ruleset array_api_ruleset) +(function DType_float64 () DType) +(rewrite (astype (NDArray_scalar (Value_int (Int___init__ i))) (DType_float64)) (NDArray_scalar (Value_float (Float___init__ (to-f64 i)))) :ruleset array_api_ruleset) +(sort OptionalInt) +(function concat (TupleNDArray OptionalInt) NDArray) +(function TupleNDArray___init__ (NDArray) TupleNDArray) +(function OptionalInt_none () OptionalInt) +(rewrite (concat (TupleNDArray___init__ x) (OptionalInt_none)) x :ruleset array_api_ruleset) +(rewrite (unique_values (unique_values x)) (unique_values x) :ruleset array_api_ruleset) +(rewrite (sum (NDArray___truediv__ x (NDArray_scalar v)) (OptionalIntOrTuple_none)) (NDArray___truediv__ (sum x (OptionalIntOrTuple_none)) (NDArray_scalar v)) :ruleset array_api_ruleset) +(function NDArray_ndim (NDArray) Int) +(sort OptionalDType) +(sort OptionalDevice) +(function asarray (NDArray OptionalDType OptionalBool OptionalDevice) NDArray) +(function OptionalDevice_none () OptionalDevice) +(rewrite (NDArray_ndim (asarray a d ob (OptionalDevice_none))) (NDArray_ndim a) :ruleset array_api_ruleset) +(function OptionalDType_none () OptionalDType) +(function OptionalBool_none () OptionalBool) +(rewrite (asarray a (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) a :ruleset array_api_ruleset) +(function TupleNDArray___add__ (TupleNDArray TupleNDArray) TupleNDArray) +(function TupleNDArray_EMPTY () TupleNDArray) +(rewrite (TupleNDArray___add__ ti (TupleNDArray_EMPTY)) ti :ruleset array_api_ruleset) +(rewrite (TupleNDArray_length (TupleNDArray___init__ n)) (Int___init__ 1) :ruleset array_api_ruleset) +(rewrite (TupleNDArray_length (TupleNDArray___add__ ti ti2)) (Int___add__ (TupleNDArray_length ti) (TupleNDArray_length ti2)) :ruleset array_api_ruleset) +(sort UnstableFn_Value_TupleInt (UnstableFn (TupleInt) Value)) +(function NDArray___init__ (TupleInt DType UnstableFn_Value_TupleInt) NDArray) +(rewrite (NDArray_shape (NDArray___init__ shape dtype idx_fn)) shape :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (NDArray___init__ shape dtype idx_fn)) dtype :ruleset array_api_ruleset) +(rewrite (NDArray_ndim x) (TupleInt_length (NDArray_shape x)) :ruleset array_api_ruleset) +(function NDArray_to_value (NDArray) Value) +(rewrite (NDArray_to_value x) (NDArray_index x (TupleInt_EMPTY)) :ruleset array_api_ruleset) +(rewrite (NDArray___truediv__ (NDArray_scalar (Value_float f)) (NDArray_scalar (Value_float f))) (NDArray_scalar (Value_float (Float___init__ 1.0))) :ruleset array_api_ruleset) +(function NDArray___sub__ (NDArray NDArray) NDArray) +(rewrite (NDArray___sub__ (NDArray_scalar (Value_float f)) (NDArray_scalar (Value_float f))) (NDArray_scalar (Value_float (Float___init__ 0.0))) :ruleset array_api_ruleset) +(function NDArray___gt__ (NDArray NDArray) NDArray) +(rewrite (NDArray___gt__ (NDArray_scalar (Value_float (Float___init__ fi1))) (NDArray_scalar (Value_float (Float___init__ fi2)))) (NDArray_scalar (Value_bool (TRUE))) :when ((> fi1 fi2)) :ruleset array_api_ruleset) +(rewrite (NDArray___gt__ (NDArray_scalar (Value_float (Float___init__ fi1))) (NDArray_scalar (Value_float (Float___init__ fi2)))) (NDArray_scalar (Value_bool (FALSE))) :when ((<= fi1 fi2)) :ruleset array_api_ruleset) +(function NDArray_T (NDArray) NDArray) +(rewrite (NDArray_T (NDArray_T x)) x :ruleset array_api_ruleset) +(function TupleValue___add__ (TupleValue TupleValue) TupleValue) +(function TupleValue_EMPTY () TupleValue) +(rewrite (TupleValue___add__ ti (TupleValue_EMPTY)) ti :ruleset array_api_ruleset) +(rewrite (TupleValue_length (TupleValue_EMPTY)) (Int___init__ 0) :ruleset array_api_ruleset) +(rewrite (TupleValue_length (TupleValue___init__ v)) (Int___init__ 1) :ruleset array_api_ruleset) +(rewrite (TupleValue_length (TupleValue___add__ ti ti2)) (Int___add__ (TupleValue_length ti) (TupleValue_length ti2)) :ruleset array_api_ruleset) +(rewrite (TupleValue___getitem__ (TupleValue___init__ v) (Int___init__ 0)) v :ruleset array_api_ruleset) +(rewrite (TupleValue___getitem__ (TupleValue___add__ (TupleValue___init__ v) ti) (Int___init__ 0)) v :ruleset array_api_ruleset) +(rule ((= v (TupleValue___getitem__ (TupleValue___add__ (TupleValue___init__ v2) ti) (Int___init__ k))) + (> k 0)) + ((union v (TupleValue___getitem__ ti (Int___init__ (- k 1))))) + :ruleset array_api_ruleset ) +(rewrite (TupleValue_includes (TupleValue_EMPTY) v) (FALSE) :ruleset array_api_ruleset) +(rewrite (TupleValue_includes (TupleValue___init__ v) v) (TRUE) :ruleset array_api_ruleset) +(rewrite (TupleValue_includes (TupleValue___init__ v) v2) (FALSE) :when ((!= v v2)) :ruleset array_api_ruleset) +(rewrite (TupleValue_includes (TupleValue___add__ ti ti2) v) (Boolean___or__ (TupleValue_includes ti v) (TupleValue_includes ti2 v)) :ruleset array_api_ruleset) +(function DType_int64 () DType) +(rewrite (Value_dtype (Value_int i)) (DType_int64) :ruleset array_api_ruleset) +(rewrite (Value_dtype (Value_float f)) (DType_float64) :ruleset array_api_ruleset) +(function DType_bool () DType) +(rewrite (Value_dtype (Value_bool b)) (DType_bool) :ruleset array_api_ruleset) +(function Value_to_bool (Value) Boolean) +(rewrite (Value_to_bool (Value_bool b)) b :ruleset array_api_ruleset) +(function Value_to_int (Value) Int) +(rewrite (Value_to_int (Value_int i)) i :ruleset array_api_ruleset) +(rewrite (Value_to_truthy_value (Value_bool b)) (Value_bool b) :ruleset array_api_ruleset) +(sort IsDtypeKind) +(function isdtype (DType IsDtypeKind) Boolean) +(function DType_float32 () DType) +(function IsDtypeKind_string (String) IsDtypeKind) +(rewrite (isdtype (DType_float32) (IsDtypeKind_string "integral")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float64) (IsDtypeKind_string "integral")) (FALSE) :ruleset array_api_ruleset) +(function DType_object () DType) +(rewrite (isdtype (DType_object) (IsDtypeKind_string "integral")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int64) (IsDtypeKind_string "integral")) (TRUE) :ruleset array_api_ruleset) +(function DType_int32 () DType) +(rewrite (isdtype (DType_int32) (IsDtypeKind_string "integral")) (TRUE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float32) (IsDtypeKind_string "real floating")) (TRUE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float64) (IsDtypeKind_string "real floating")) (TRUE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_object) (IsDtypeKind_string "real floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int64) (IsDtypeKind_string "real floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int32) (IsDtypeKind_string "real floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float32) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float64) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_object) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int64) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int32) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(function IsDtypeKind_NULL () IsDtypeKind) +(rewrite (isdtype d (IsDtypeKind_NULL)) (FALSE) :ruleset array_api_ruleset) +(function IsDtypeKind_dtype (DType) IsDtypeKind) +(rewrite (isdtype d (IsDtypeKind_dtype d)) (TRUE) :ruleset array_api_ruleset) +(function IsDtypeKind___or__ (IsDtypeKind IsDtypeKind) IsDtypeKind :cost 10) +(rewrite (isdtype d (IsDtypeKind___or__ k1 k2)) (Boolean___or__ (isdtype d k1) (isdtype d k2)) :ruleset array_api_ruleset) +(rewrite (IsDtypeKind___or__ k1 (IsDtypeKind_NULL)) k1 :ruleset array_api_ruleset) +(function DType___eq__ (DType DType) Boolean) +(rewrite (DType___eq__ (DType_float64) (DType_float64)) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float64) (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float64) (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float64) (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float64) (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_float64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_float32)) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_float64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_int32)) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_float64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_int64)) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_float64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_object)) (TRUE) :ruleset array_api_ruleset) +(function idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___ (UnstableFn_Int_Int Int) Int) +(rewrite (idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___ idx_fn i) (unstable-app idx_fn (Int___add__ i (Int___init__ 1))) :ruleset array_api_ruleset) +(rewrite (TupleInt_length (TupleInt___init__ i idx_fn)) i :ruleset array_api_ruleset) +(rewrite (TupleInt___getitem__ (TupleInt___init__ i idx_fn) i2) (unstable-app idx_fn i2) :ruleset array_api_ruleset) +(rewrite (index_vec_int vs (Int___init__ k)) (vec-get vs k) :when ((> (vec-length vs) k)) :ruleset array_api_ruleset) +(rewrite (TupleInt_fold (TupleInt___init__ (Int___init__ 0) idx_fn) i f) i :ruleset array_api_ruleset) +(rewrite (TupleInt_fold (TupleInt___init__ (Int___init__ k) idx_fn) i f) (unstable-app f (TupleInt_fold (TupleInt___init__ (Int___init__ (- k 1)) (unstable-fn "idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___" idx_fn)) i f) (unstable-app idx_fn (Int___init__ 0))) :when ((!= k 0)) :ruleset array_api_ruleset) +(rewrite (TupleInt_fold_boolean (TupleInt___init__ (Int___init__ 0) idx_fn) b bool_f) b :ruleset array_api_ruleset) +(rewrite (TupleInt_fold_boolean (TupleInt___init__ (Int___init__ k) idx_fn) b bool_f) (unstable-app bool_f (TupleInt_fold_boolean (TupleInt___init__ (Int___init__ (- k 1)) (unstable-fn "idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___" idx_fn)) b bool_f) (unstable-app idx_fn (Int___init__ 0))) :when ((!= k 0)) :ruleset array_api_ruleset) +(sort UnstableFn_Boolean_Int (UnstableFn (Int) Boolean)) +(function TupleInt_filter (TupleInt UnstableFn_Boolean_Int) TupleInt :cost 100) +(rewrite (TupleInt_filter (TupleInt___init__ (Int___init__ 0) idx_fn) filter_f) (TupleInt___init__ (Int___init__ 0) idx_fn) :ruleset array_api_ruleset) +(function TupleInt_if_ (Boolean TupleInt TupleInt) TupleInt) +(rewrite (TupleInt_filter (TupleInt___init__ (Int___init__ k) idx_fn) filter_f) (TupleInt_if_ (unstable-app filter_f (unstable-app idx_fn (Int___init__ k))) (TupleInt___add__ (TupleInt_single (unstable-app idx_fn (Int___init__ k))) (TupleInt_filter (TupleInt___init__ (Int___init__ (- k 1)) (unstable-fn "idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___" idx_fn)) filter_f)) (TupleInt_filter (TupleInt___init__ (Int___init__ (- k 1)) (unstable-fn "idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___" idx_fn)) filter_f)) :when ((!= k 0)) :ruleset array_api_ruleset) +(function bottom_indexing (Int) Int) +(rewrite (TupleInt_EMPTY) (TupleInt___init__ (Int___init__ 0) (unstable-fn "bottom_indexing")) :ruleset array_api_ruleset) +(rewrite (TupleInt_if_ (TRUE) ti ti2) ti :ruleset array_api_ruleset) +(rewrite (TupleInt_if_ (FALSE) ti ti2) ti2 :ruleset array_api_ruleset) +(rewrite (Float_abs (Float___init__ f)) (Float___init__ f) :when ((>= f 0.0)) :ruleset array_api_ruleset) +(rewrite (Float_abs (Float___init__ f)) (Float___init__ (neg f)) :when ((< f 0.0)) :ruleset array_api_ruleset) +(function Float_rational (Rational) Float :cost 2) +(rewrite (Float___init__ f) (Float_rational (rational (to-i64 f) 1)) :when ((= (to-f64 (to-i64 f)) f)) :ruleset array_api_ruleset) +(function Float_from_int (Int) Float) +(rewrite (Float_from_int (Int___init__ i)) (Float_rational (rational i 1)) :ruleset array_api_ruleset) +(function Float___add__ (Float Float) Float) +(rewrite (Float___add__ (Float___init__ f) (Float___init__ f2)) (Float___init__ (+ f f2)) :ruleset array_api_ruleset) +(function Float___sub__ (Float Float) Float) +(rewrite (Float___sub__ (Float___init__ f) (Float___init__ f2)) (Float___init__ (- f f2)) :ruleset array_api_ruleset) +(function Float___mul__ (Float Float) Float) +(rewrite (Float___mul__ (Float___init__ f) (Float___init__ f2)) (Float___init__ (* f f2)) :ruleset array_api_ruleset) +(function Float___truediv__ (Float Float) Float) +(rewrite (Float___truediv__ (Float_rational r) (Float_rational r1)) (Float_rational (/ r r1)) :ruleset array_api_ruleset) +(rewrite (Float___add__ (Float_rational r) (Float_rational r1)) (Float_rational (+ r r1)) :ruleset array_api_ruleset) +(rewrite (Float___sub__ (Float_rational r) (Float_rational r1)) (Float_rational (- r r1)) :ruleset array_api_ruleset) +(rewrite (Float___mul__ (Float_rational r) (Float_rational r1)) (Float_rational (* r r1)) :ruleset array_api_ruleset) +(rewrite (Int___eq__ (Int___init__ i) (Int___init__ i)) (TRUE) :ruleset array_api_ruleset) +(rule ((= r (Int___eq__ (Int___init__ i) (Int___init__ j))) + (!= i j)) + ((union r (FALSE))) + :ruleset array_api_ruleset ) +(function Int___ge__ (Int Int) Boolean) +(rewrite (Int___ge__ (Int___init__ i) (Int___init__ i)) (TRUE) :ruleset array_api_ruleset) +(rule ((= r (Int___ge__ (Int___init__ i) (Int___init__ j))) + (> i j)) + ((union r (TRUE))) + :ruleset array_api_ruleset ) +(rule ((= r (Int___ge__ (Int___init__ i) (Int___init__ j))) + (< i j)) + ((union r (FALSE))) + :ruleset array_api_ruleset ) +(rewrite (Int___lt__ (Int___init__ i) (Int___init__ i)) (FALSE) :ruleset array_api_ruleset) +(rule ((= r (Int___lt__ (Int___init__ i) (Int___init__ j))) + (< i j)) + ((union r (TRUE))) + :ruleset array_api_ruleset ) +(rule ((= r (Int___lt__ (Int___init__ i) (Int___init__ j))) + (> i j)) + ((union r (FALSE))) + :ruleset array_api_ruleset ) +(function Int___gt__ (Int Int) Boolean) +(rewrite (Int___gt__ (Int___init__ i) (Int___init__ i)) (FALSE) :ruleset array_api_ruleset) +(rule ((= r (Int___gt__ (Int___init__ i) (Int___init__ j))) + (> i j)) + ((union r (TRUE))) + :ruleset array_api_ruleset ) +(rule ((= r (Int___gt__ (Int___init__ i) (Int___init__ j))) + (< i j)) + ((union r (FALSE))) + :ruleset array_api_ruleset ) +(function Int_i64 (Int) i64) +(rule ((= o (Int___init__ j))) + ((set (Int_i64 o) j)) + :ruleset array_api_ruleset ) +(rewrite (Int___add__ (Int___init__ i) (Int___init__ j)) (Int___init__ (+ i j)) :ruleset array_api_ruleset) +(rewrite (Int___sub__ (Int___init__ i) (Int___init__ j)) (Int___init__ (- i j)) :ruleset array_api_ruleset) +(rewrite (Int___mul__ (Int___init__ i) (Int___init__ j)) (Int___init__ (* i j)) :ruleset array_api_ruleset) +(function Int___truediv__ (Int Int) Int) +(rewrite (Int___truediv__ (Int___init__ i) (Int___init__ j)) (Int___init__ (/ i j)) :ruleset array_api_ruleset) +(function Int___mod__ (Int Int) Int) +(rewrite (Int___mod__ (Int___init__ i) (Int___init__ j)) (Int___init__ (% i j)) :ruleset array_api_ruleset) +(function Int___and__ (Int Int) Int) +(rewrite (Int___and__ (Int___init__ i) (Int___init__ j)) (Int___init__ (& i j)) :ruleset array_api_ruleset) +(function Int___or__ (Int Int) Int) +(rewrite (Int___or__ (Int___init__ i) (Int___init__ j)) (Int___init__ (| i j)) :ruleset array_api_ruleset) +(function Int___xor__ (Int Int) Int) +(rewrite (Int___xor__ (Int___init__ i) (Int___init__ j)) (Int___init__ (^ i j)) :ruleset array_api_ruleset) +(function Int___lshift__ (Int Int) Int) +(rewrite (Int___lshift__ (Int___init__ i) (Int___init__ j)) (Int___init__ (<< i j)) :ruleset array_api_ruleset) +(function Int___rshift__ (Int Int) Int) +(rewrite (Int___rshift__ (Int___init__ i) (Int___init__ j)) (Int___init__ (>> i j)) :ruleset array_api_ruleset) +(function Int___invert__ (Int) Int) +(rewrite (Int___invert__ (Int___init__ i)) (Int___init__ (not-i64 i)) :ruleset array_api_ruleset) +(rewrite (Int_if_ (TRUE) o b) o :ruleset array_api_ruleset) +(rewrite (Int_if_ (FALSE) o b) b :ruleset array_api_ruleset) +(function Boolean_bool (Boolean) bool) +(rule ((= x (TRUE))) + ((set (Boolean_bool x) true)) + :ruleset array_api_ruleset ) +(rule ((= x (FALSE))) + ((set (Boolean_bool x) false)) + :ruleset array_api_ruleset ) +(rewrite (Boolean___or__ (TRUE) x) (TRUE) :ruleset array_api_ruleset) +(rewrite (Boolean___or__ (FALSE) x) x :ruleset array_api_ruleset) +(function Boolean___and__ (Boolean Boolean) Boolean) +(rewrite (Boolean___and__ (TRUE) x) x :ruleset array_api_ruleset) +(rewrite (Boolean___and__ (FALSE) x) (FALSE) :ruleset array_api_ruleset) +(function Boolean_if_int (Boolean Int Int) Int) +(rewrite (Boolean_if_int (TRUE) i j) i :ruleset array_api_ruleset) +(rewrite (Boolean_if_int (FALSE) i j) j :ruleset array_api_ruleset) +(function Boolean___invert__ (Boolean) Boolean) +(rewrite (Boolean___invert__ (TRUE)) (FALSE) :ruleset array_api_ruleset) +(rewrite (Boolean___invert__ (FALSE)) (TRUE) :ruleset array_api_ruleset) +(ruleset ruleset_5033605696) +(function NDArray___eq__ (NDArray NDArray) NDArray) +(rewrite (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse x) (Int___init__ 1)) (NDArray_scalar (Value_int i))) (NDArray___eq__ x (NDArray_scalar (NDArray_index (unique_values x) (TupleInt_from_vec (vec-of i))))) :subsume :ruleset ruleset_5033605696) +(function count_values (NDArray NDArray) TupleValue :unextractable) +(rewrite (TupleNDArray___getitem__ (unique_counts x) (Int___init__ 1)) (NDArray_vector (count_values x (unique_values x))) :subsume :ruleset ruleset_5033605696) +(rewrite (count_values x (NDArray_vector (TupleValue___add__ (TupleValue___init__ v) tv))) (TupleValue___add__ (TupleValue___init__ (NDArray_to_value (sum (NDArray___eq__ x (NDArray_scalar v)) (OptionalIntOrTuple_none)))) (count_values x (NDArray_vector tv))) :subsume :ruleset ruleset_5033605696) +(rewrite (count_values x (NDArray_vector (TupleValue___init__ v))) (TupleValue___init__ (NDArray_to_value (sum (NDArray___eq__ x (NDArray_scalar v)) (OptionalIntOrTuple_none)))) :subsume :ruleset ruleset_5033605696) +(function std (NDArray OptionalIntOrTuple) NDArray) +(sort IntOrTuple) +(function OptionalIntOrTuple_some (IntOrTuple) OptionalIntOrTuple) +(function IntOrTuple_int (Int) IntOrTuple) +(function ndarray-sqrt (NDArray) NDArray) +(function mean (NDArray OptionalIntOrTuple Boolean) NDArray) +(function square (NDArray) NDArray) +(rewrite (std x (OptionalIntOrTuple_some (IntOrTuple_int i))) (ndarray-sqrt (mean (square (NDArray___sub__ x (mean x (OptionalIntOrTuple_some (IntOrTuple_int i)) (TRUE)))) (OptionalIntOrTuple_some (IntOrTuple_int i)) (FALSE))) :subsume :ruleset ruleset_5033605696) +(rewrite (mean x (OptionalIntOrTuple_some (IntOrTuple_int i)) (FALSE)) (NDArray___truediv__ (sum x (OptionalIntOrTuple_some (IntOrTuple_int i))) (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape x) i)))) :subsume :ruleset ruleset_5033605696) +(function expand_dims (NDArray Int) NDArray) +(rewrite (mean x (OptionalIntOrTuple_some (IntOrTuple_int i)) (TRUE)) (expand_dims (NDArray___truediv__ (sum x (OptionalIntOrTuple_some (IntOrTuple_int i))) (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape x) i)))) i) :subsume :ruleset ruleset_5033605696) +(let %__expr_-4122594143565222517 (OptionalBool_none)) +(let %__expr_-3674731718720096444 (OptionalDevice_none)) +(let %__expr_2091604061025500396 (OptionalDType_none)) +(function NDArray_var (String) NDArray :cost 200) +(let %__expr_-5200143055942215294 (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444) (TupleInt_from_vec (vec-of (Int___init__ -1))) %__expr_-4122594143565222517) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) +(let %__expr_3300329792522185471 (Int___init__ 1)) +(let %__expr_-7942988945600443502 (Int___init__ 0)) +(let %__expr_2407075622821899710 (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray %__expr_-5200143055942215294 %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) %__expr_-7942988945600443502)) +(let %__expr_-143818766793636568 (OptionalInt_none)) +(let %__expr_2305922367412063525 (Int___init__ 2)) +(let %__expr_-1113027338580586528 (unique_values (concat (TupleNDArray___init__ (unique_values (asarray %__expr_-5200143055942215294 %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) (OptionalInt_none)))) +(let %__expr_4326809257670680665 (IndexKey_int %__expr_-7942988945600443502)) +(let %__expr_-6932009612334166206 (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_-7942988945600443502)) +(sort MultiAxisIndexKey) +(function IndexKey_multi_axis (MultiAxisIndexKey) IndexKey) +(sort MultiAxisIndexKeyItem) +(sort Vec_MultiAxisIndexKeyItem (Vec MultiAxisIndexKeyItem)) +(function MultiAxisIndexKey_from_vec (Vec_MultiAxisIndexKeyItem) MultiAxisIndexKey) +(function MultiAxisIndexKeyItem_int (Int) MultiAxisIndexKeyItem) +(sort Slice) +(function MultiAxisIndexKeyItem_slice (Slice) MultiAxisIndexKeyItem) +(function Slice___init__ (OptionalInt OptionalInt OptionalInt) Slice) +(let %__expr_-954298076671303615 (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_2305922367412063525) (MultiAxisIndexKeyItem_slice (Slice___init__ %__expr_-143818766793636568 %__expr_-143818766793636568 %__expr_-143818766793636568)))))) +(let %__expr_483064111004974365 (Float___init__ 1.0)) +(let %__expr_-3520630818915629594 (Int___init__ 150)) +(let %__expr_-6765600943420531488 (Value_int (Int___init__ 2))) +(let %__expr_-622493510873225930 (Value_int (Int___init__ 1))) +(let %__expr_478758938070675600 (Value_int (Int___init__ 0))) +(let %__expr_-8664633617851008504 (unique_inverse %__expr_-5200143055942215294)) +(let %__expr_-8613124149453883591 (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) +(let %__expr_-8637348939342624324 (MultiAxisIndexKeyItem_slice (Slice___init__ %__expr_-143818766793636568 %__expr_-143818766793636568 %__expr_-143818766793636568))) +(let %__expr_-2704792733181451377 (TupleNDArray___getitem__ %__expr_-8664633617851008504 %__expr_3300329792522185471)) +(let %__expr_1913846200346632608 (OptionalIntOrTuple_some (IntOrTuple_int %__expr_-7942988945600443502))) +(let %__expr_6185990579165616281 (FALSE)) +(function NDArray___setitem__ (NDArray IndexKey NDArray) NDArray) +(function zeros (TupleInt OptionalDType OptionalDevice) NDArray) +(function OptionalDType_some (DType) OptionalDType) +(sort Device) +(function OptionalDevice_some (Device) OptionalDevice) +(function NDArray_device (NDArray) Device) +(function IndexKey_ndarray (NDArray) IndexKey) +(let %__expr_7843526591494960327 (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ %__expr_-8664633617851008504 %__expr_-7942988945600443502)) %__expr_-7942988945600443502) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) %__expr_3300329792522185471))) (OptionalDType_some (NDArray_dtype %__expr_-8613124149453883591)) (OptionalDevice_some (NDArray_device %__expr_-8613124149453883591))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_-7942988945600443502) %__expr_-8637348939342624324))) (mean (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-2704792733181451377 (NDArray_scalar %__expr_478758938070675600)))) %__expr_1913846200346632608 %__expr_6185990579165616281)) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_3300329792522185471) %__expr_-8637348939342624324))) (mean (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-2704792733181451377 (NDArray_scalar %__expr_-622493510873225930)))) %__expr_1913846200346632608 %__expr_6185990579165616281)) %__expr_-954298076671303615 (mean (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-2704792733181451377 (NDArray_scalar %__expr_-6765600943420531488)))) %__expr_1913846200346632608 %__expr_6185990579165616281))) +(let %__expr_7180621784385959982 (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_3300329792522185471) %__expr_-8637348939342624324)))) +(let %__expr_-3283806677371465170 (NDArray_scalar %__expr_478758938070675600)) +(let %__expr_-4323225966908438009 (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_-7942988945600443502) %__expr_-8637348939342624324)))) +(let %__expr_-8475266842302933511 (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444))) +(function OptionalInt_some (Int) OptionalInt) +(let %__expr_3049932803880609425 (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 %__expr_4326809257670680665)))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_-4323225966908438009))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 (IndexKey_int %__expr_3300329792522185471))))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_7180621784385959982))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 (IndexKey_int %__expr_2305922367412063525))))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_-954298076671303615))))) (OptionalInt_some %__expr_-7942988945600443502)) %__expr_1913846200346632608)) +(let %__expr_-671931098406187877 (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 %__expr_4326809257670680665)))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_-4323225966908438009))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 (IndexKey_int %__expr_3300329792522185471))))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_7180621784385959982))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ %__expr_-8613124149453883591 (IndexKey_ndarray (NDArray___eq__ %__expr_-5200143055942215294 (NDArray___getitem__ %__expr_-1113027338580586528 (IndexKey_int %__expr_2305922367412063525))))) (NDArray___getitem__ %__expr_7843526591494960327 %__expr_-954298076671303615))))) (OptionalInt_some %__expr_-7942988945600443502))) +(function NDArray___mul__ (NDArray NDArray) NDArray) +(let %__expr_-1459297673498492435 (Slice___init__ %__expr_-143818766793636568 (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ %__expr_-6932009612334166206 %__expr_2407075622821899710))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (NDArray___truediv__ %__expr_-671931098406187877 (NDArray___setitem__ %__expr_3049932803880609425 (IndexKey_ndarray (NDArray___eq__ %__expr_3049932803880609425 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) %__expr_6185990579165616281) %__expr_3300329792522185471) (NDArray_scalar (Value_float (Float___init__ 0.0001)))) (DType_int32)) (OptionalIntOrTuple_none))))) %__expr_-143818766793636568)) +(let %__expr_4799320818084596281 (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ %__expr_-6932009612334166206 %__expr_2407075622821899710))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (NDArray___truediv__ %__expr_-671931098406187877 (NDArray___setitem__ %__expr_3049932803880609425 (IndexKey_ndarray (NDArray___eq__ %__expr_3049932803880609425 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) %__expr_6185990579165616281)) +(let %__expr_-4744074158064860754 (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ %__expr_-6932009612334166206 %__expr_2407075622821899710))))) %__expr_2091604061025500396 %__expr_-4122594143565222517 %__expr_-3674731718720096444)) (NDArray___truediv__ %__expr_-671931098406187877 (NDArray___setitem__ %__expr_3049932803880609425 (IndexKey_ndarray (NDArray___eq__ %__expr_3049932803880609425 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) %__expr_6185990579165616281) %__expr_3300329792522185471)) +(let %__expr_2307122782736907488 (NDArray___setitem__ %__expr_3049932803880609425 (IndexKey_ndarray (NDArray___eq__ %__expr_3049932803880609425 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float___init__ 1.0))))) +(function NDArray___matmul__ (NDArray NDArray) NDArray) +(function IndexKey_slice (Slice) IndexKey) +(let %__expr_270530672567316052 (TupleNDArray___getitem__ (svd (NDArray___matmul__ (NDArray_T (NDArray___mul__ (ndarray-sqrt (NDArray___mul__ (NDArray___mul__ (NDArray_scalar (Value_int %__expr_-6932009612334166206)) (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts %__expr_-5200143055942215294) %__expr_3300329792522185471) (NDArray_dtype %__expr_-8613124149453883591)) (NDArray_scalar (Value_float (Float___init__ 150.0))))) (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ %__expr_2407075622821899710 %__expr_3300329792522185471))))))) (NDArray_T (NDArray___sub__ %__expr_7843526591494960327 (NDArray___matmul__ (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts %__expr_-5200143055942215294) %__expr_3300329792522185471) (NDArray_dtype %__expr_-8613124149453883591)) (NDArray_scalar (Value_float (Float___init__ 150.0)))) %__expr_7843526591494960327))))) (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ %__expr_4799320818084596281 %__expr_2305922367412063525) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice %__expr_-1459297673498492435) %__expr_-8637348939342624324)))) %__expr_2307122782736907488)) (NDArray___getitem__ %__expr_-4744074158064860754 (IndexKey_slice %__expr_-1459297673498492435)))) %__expr_6185990579165616281) %__expr_3300329792522185471)) +(let %__expr_-5540247018246576406 (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts %__expr_-5200143055942215294) %__expr_3300329792522185471) (NDArray_dtype %__expr_-8613124149453883591)) (NDArray_scalar (Value_float (Float___init__ 150.0))))) +(let %__expr_-5933626871507061239 (svd (NDArray___matmul__ (NDArray_T (NDArray___mul__ (ndarray-sqrt (NDArray___mul__ (NDArray___mul__ (NDArray_scalar (Value_int %__expr_-6932009612334166206)) (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts %__expr_-5200143055942215294) %__expr_3300329792522185471) (NDArray_dtype %__expr_-8613124149453883591)) (NDArray_scalar (Value_float (Float___init__ 150.0))))) (NDArray_scalar (Value_float (Float___truediv__ %__expr_483064111004974365 (Float_from_int (Int___sub__ %__expr_2407075622821899710 %__expr_3300329792522185471))))))) (NDArray_T (NDArray___sub__ %__expr_7843526591494960327 (NDArray___matmul__ (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts %__expr_-5200143055942215294) %__expr_3300329792522185471) (NDArray_dtype %__expr_-8613124149453883591)) (NDArray_scalar (Value_float (Float___init__ 150.0)))) %__expr_7843526591494960327))))) (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ %__expr_4799320818084596281 %__expr_2305922367412063525) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice %__expr_-1459297673498492435) %__expr_-8637348939342624324)))) %__expr_2307122782736907488)) (NDArray___getitem__ %__expr_-4744074158064860754 (IndexKey_slice %__expr_-1459297673498492435)))) %__expr_6185990579165616281)) +(let %__expr_-4180228001421012884 (NDArray_scalar (Value_float (Float___init__ 0.0001)))) +(let %__expr_-3501279694271260104 (DType_int32)) +(let %__expr_5981948135265815040 (OptionalIntOrTuple_none)) +(let %__expr_2917853313867759590 (NDArray_dtype %__expr_-8613124149453883591)) +(let %__expr_-5161099022452562755 (NDArray___matmul__ (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts %__expr_-5200143055942215294) %__expr_3300329792522185471) (NDArray_dtype %__expr_-8613124149453883591)) (NDArray_scalar (Value_float (Float___init__ 150.0)))) %__expr_7843526591494960327)) +(let %__expr_7947521701427986423 (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ %__expr_4799320818084596281 %__expr_2305922367412063525) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice %__expr_-1459297673498492435) %__expr_-8637348939342624324)))) %__expr_2307122782736907488)) (NDArray___getitem__ %__expr_-4744074158064860754 (IndexKey_slice %__expr_-1459297673498492435)))) +(simplify (saturate (seq (run array_api_ruleset) (run ruleset_5033605696))) (NDArray___getitem__ (NDArray___matmul__ (NDArray___sub__ %__expr_-8613124149453883591 %__expr_-5161099022452562755) (NDArray___matmul__ %__expr_7947521701427986423 (NDArray___getitem__ (NDArray_T (TupleNDArray___getitem__ %__expr_-5933626871507061239 %__expr_2305922367412063525)) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of %__expr_-8637348939342624324 (MultiAxisIndexKeyItem_slice (Slice___init__ %__expr_-143818766793636568 (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ %__expr_270530672567316052 (NDArray___mul__ %__expr_-4180228001421012884 (NDArray___getitem__ %__expr_270530672567316052 %__expr_4326809257670680665))) %__expr_-3501279694271260104) %__expr_5981948135265815040)))) %__expr_-143818766793636568)))))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of %__expr_-8637348939342624324 (MultiAxisIndexKeyItem_slice (Slice___init__ %__expr_-143818766793636568 (OptionalInt_some %__expr_2305922367412063525) %__expr_-143818766793636568))))))) +(let %__expr_978886785202701864 (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of %__expr_-3520630818915629594 (Int___init__ 4)))))) +(let %__expr_3826936542596060759 (Int___init__ 4)) +(let %__expr_-8607724285922497289 (NDArray___getitem__ %__expr_978886785202701864 (IndexKey_ndarray (NDArray___eq__ (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of %__expr_-3520630818915629594))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (NDArray_scalar %__expr_-622493510873225930))))) +(let %__expr_8779256037532389381 (NDArray___getitem__ %__expr_978886785202701864 (IndexKey_ndarray (NDArray___eq__ (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of %__expr_-3520630818915629594))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) %__expr_-3283806677371465170)))) +(let %__expr_2565664028803046192 (DType_float64)) +(let %__expr_3562727526135681919 (NDArray___getitem__ %__expr_978886785202701864 (IndexKey_ndarray (NDArray___eq__ (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of %__expr_-3520630818915629594))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (NDArray_scalar %__expr_-6765600943420531488))))) +(let %__expr_5127641217187406832 (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of %__expr_-3520630818915629594))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2))))))) +(let %__expr_-5874110021677832412 (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_-7942988945600443502) %__expr_-8637348939342624324)))) +(let %__expr_2924140249920978521 (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (Int___init__ 3) %__expr_3826936542596060759)) (OptionalDType_some %__expr_2565664028803046192) (OptionalDevice_some (NDArray_device %__expr_978886785202701864))) %__expr_-5874110021677832412 (NDArray___truediv__ (sum %__expr_8779256037532389381 %__expr_1913846200346632608) (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape %__expr_8779256037532389381) %__expr_-7942988945600443502))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_3300329792522185471) %__expr_-8637348939342624324))) (NDArray___truediv__ (sum %__expr_-8607724285922497289 %__expr_1913846200346632608) (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape %__expr_-8607724285922497289) %__expr_-7942988945600443502))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_2305922367412063525) %__expr_-8637348939342624324))) (NDArray___truediv__ (sum %__expr_3562727526135681919 %__expr_1913846200346632608) (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape %__expr_3562727526135681919) %__expr_-7942988945600443502)))))) +(let %__expr_8582344284568866371 (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_2305922367412063525) %__expr_-8637348939342624324)))) +(let %__expr_-3132706819403651174 (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ %__expr_8779256037532389381 (NDArray___getitem__ %__expr_2924140249920978521 %__expr_-5874110021677832412))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ %__expr_-8607724285922497289 (NDArray___getitem__ %__expr_2924140249920978521 (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_3300329792522185471) %__expr_-8637348939342624324)))))) (TupleNDArray___init__ (NDArray___sub__ %__expr_3562727526135681919 (NDArray___getitem__ %__expr_2924140249920978521 %__expr_8582344284568866371))))) (OptionalInt_some %__expr_-7942988945600443502))) +(let %__expr_755766186975356825 (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int %__expr_3300329792522185471) %__expr_-8637348939342624324)))) +(let %__expr_1540266631570115279 (NDArray___eq__ (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of %__expr_-3520630818915629594))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (NDArray_scalar %__expr_-622493510873225930))) +(let %__expr_7382830492167037887 (square (NDArray___sub__ %__expr_-3132706819403651174 (expand_dims (NDArray___truediv__ (sum %__expr_-3132706819403651174 %__expr_1913846200346632608) (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape %__expr_-3132706819403651174) %__expr_-7942988945600443502)))) %__expr_-7942988945600443502)))) +(let %__expr_-8085216922850384227 1) +(let %__expr_-6293504624159906607 (ndarray-sqrt (NDArray___truediv__ (sum %__expr_7382830492167037887 %__expr_1913846200346632608) (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape %__expr_7382830492167037887) %__expr_-7942988945600443502)))))) +(let %__expr_6749312899897339687 (Slice___init__ %__expr_-143818766793636568 (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (NDArray_scalar (Value_float (Float_rational (rational %__expr_-8085216922850384227 147))))) (NDArray___truediv__ %__expr_-3132706819403651174 (NDArray___setitem__ %__expr_-6293504624159906607 (IndexKey_ndarray (NDArray___eq__ %__expr_-6293504624159906607 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float_rational (rational %__expr_-8085216922850384227 %__expr_-8085216922850384227))))))) %__expr_6185990579165616281) %__expr_3300329792522185471) %__expr_-4180228001421012884) %__expr_-3501279694271260104) %__expr_5981948135265815040)))) %__expr_-143818766793636568)) +(let %__expr_-5507881356079575778 (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (NDArray_scalar (Value_float (Float_rational (rational %__expr_-8085216922850384227 147))))) (NDArray___truediv__ %__expr_-3132706819403651174 (NDArray___setitem__ %__expr_-6293504624159906607 (IndexKey_ndarray (NDArray___eq__ %__expr_-6293504624159906607 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float_rational (rational %__expr_-8085216922850384227 %__expr_-8085216922850384227))))))) %__expr_6185990579165616281) %__expr_3300329792522185471)) +(let %__expr_-649824781713772813 (NDArray___eq__ (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of %__expr_-3520630818915629594))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) %__expr_-3283806677371465170)) +(let %__expr_-7715872950595615314 (svd (NDArray___mul__ (ndarray-sqrt (NDArray_scalar (Value_float (Float_rational (rational %__expr_-8085216922850384227 147))))) (NDArray___truediv__ %__expr_-3132706819403651174 (NDArray___setitem__ %__expr_-6293504624159906607 (IndexKey_ndarray (NDArray___eq__ %__expr_-6293504624159906607 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float_rational (rational %__expr_-8085216922850384227 %__expr_-8085216922850384227))))))) %__expr_6185990579165616281)) +(let %__expr_-3823036485969157667 150) +(let %__expr_-5209865760313326585 (NDArray___truediv__ (astype (NDArray_vector (TupleValue___add__ (TupleValue___init__ (NDArray_to_value (sum %__expr_-649824781713772813 %__expr_5981948135265815040))) (TupleValue___add__ (TupleValue___init__ (NDArray_to_value (sum %__expr_1540266631570115279 %__expr_5981948135265815040))) (TupleValue___init__ (NDArray_to_value (sum (NDArray___eq__ (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of %__expr_-3520630818915629594))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (NDArray_scalar %__expr_-6765600943420531488)) %__expr_5981948135265815040)))))) %__expr_2565664028803046192) (NDArray_scalar (Value_float (Float_rational (rational %__expr_-3823036485969157667 %__expr_-8085216922850384227)))))) +(let %__expr_3134672938439589730 (NDArray___setitem__ %__expr_-6293504624159906607 (IndexKey_ndarray (NDArray___eq__ %__expr_-6293504624159906607 %__expr_-3283806677371465170)) (NDArray_scalar (Value_float (Float_rational (rational %__expr_-8085216922850384227 %__expr_-8085216922850384227)))))) +(let %__expr_2615935926139764667 (TupleNDArray___getitem__ (svd (NDArray___matmul__ (NDArray_T (NDArray___mul__ (ndarray-sqrt (NDArray___mul__ (NDArray___mul__ (NDArray_scalar (Value_int %__expr_-3520630818915629594)) %__expr_-5209865760313326585) (NDArray_scalar (Value_float (Float_rational (rational %__expr_-8085216922850384227 2)))))) (NDArray_T (NDArray___sub__ %__expr_2924140249920978521 (NDArray___matmul__ %__expr_-5209865760313326585 %__expr_2924140249920978521))))) (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ %__expr_-7715872950595615314 %__expr_2305922367412063525) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice %__expr_6749312899897339687) %__expr_-8637348939342624324)))) %__expr_3134672938439589730)) (NDArray___getitem__ %__expr_-5507881356079575778 (IndexKey_slice %__expr_6749312899897339687)))) %__expr_6185990579165616281) %__expr_3300329792522185471)) +(let %__expr_-3749619018425312853 2) +(let %__expr_-4464433185064523998 (svd (NDArray___matmul__ (NDArray_T (NDArray___mul__ (ndarray-sqrt (NDArray___mul__ (NDArray___mul__ (NDArray_scalar (Value_int %__expr_-3520630818915629594)) %__expr_-5209865760313326585) (NDArray_scalar (Value_float (Float_rational (rational %__expr_-8085216922850384227 2)))))) (NDArray_T (NDArray___sub__ %__expr_2924140249920978521 (NDArray___matmul__ %__expr_-5209865760313326585 %__expr_2924140249920978521))))) (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ %__expr_-7715872950595615314 %__expr_2305922367412063525) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice %__expr_6749312899897339687) %__expr_-8637348939342624324)))) %__expr_3134672938439589730)) (NDArray___getitem__ %__expr_-5507881356079575778 (IndexKey_slice %__expr_6749312899897339687)))) %__expr_6185990579165616281)) +(let %__expr_8528844779137627870 (NDArray___eq__ (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of %__expr_-3520630818915629594))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (NDArray_scalar %__expr_-6765600943420531488))) +(let %__expr_4447619498771141281 (NDArray___matmul__ %__expr_-5209865760313326585 %__expr_2924140249920978521)) +(let %__expr_-2753571644920605745 (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) +(let %__expr_3259058749987290790 (assume_dtype (NDArray_var "y") (DType_int64))) +(let %__expr_-6562228218073754698 (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ %__expr_-7715872950595615314 %__expr_2305922367412063525) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice %__expr_6749312899897339687) %__expr_-8637348939342624324)))) %__expr_3134672938439589730)) (NDArray___getitem__ %__expr_-5507881356079575778 (IndexKey_slice %__expr_6749312899897339687)))) +(let %__expr_-1580149342035447281 0) +(sort Program) +(function Program_compile (Program i64) Unit :default ()) +(function ndarray_function_two_program (NDArray NDArray NDArray) Program) +(Program_compile (ndarray_function_two_program (NDArray___getitem__ (NDArray___matmul__ (NDArray___sub__ %__expr_978886785202701864 %__expr_4447619498771141281) (NDArray___matmul__ %__expr_-6562228218073754698 (NDArray___getitem__ (NDArray_T (TupleNDArray___getitem__ %__expr_-4464433185064523998 %__expr_2305922367412063525)) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of %__expr_-8637348939342624324 (MultiAxisIndexKeyItem_slice (Slice___init__ %__expr_-143818766793636568 (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ %__expr_2615935926139764667 (NDArray___mul__ %__expr_-4180228001421012884 (NDArray___getitem__ %__expr_2615935926139764667 %__expr_4326809257670680665))) %__expr_-3501279694271260104) %__expr_5981948135265815040)))) %__expr_-143818766793636568)))))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of %__expr_-8637348939342624324 (MultiAxisIndexKeyItem_slice (Slice___init__ %__expr_-143818766793636568 (OptionalInt_some %__expr_2305922367412063525) %__expr_-143818766793636568)))))) (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2))))))) %__expr_-1580149342035447281) +(ruleset array_api_program_gen_ruleset) +(function Program_function_two (Program Program Program String) Program) +(function ndarray_program (NDArray) Program) +(rewrite (ndarray_function_two_program res l r) (Program_function_two (ndarray_program res) (ndarray_program l) (ndarray_program r) "__fn") :ruleset array_api_program_gen_ruleset) +(function Program___init__ (String bool) Program) +(rewrite (ndarray_program (NDArray_var s)) (Program___init__ s true) :ruleset array_api_program_gen_ruleset) +(function Program_statement (Program Program) Program :unextractable) +(function Program___add__ (Program Program) Program) +(function dtype_program (DType) Program) +(rewrite (ndarray_program (assume_dtype z dtype)) (Program_statement (ndarray_program z) (Program___add__ (Program___add__ (Program___add__ (Program___init__ "assert " false) (ndarray_program z)) (Program___init__ ".dtype == " false)) (dtype_program dtype))) :ruleset array_api_program_gen_ruleset) +(function tuple_int_program (TupleInt) Program) +(rewrite (ndarray_program (assume_shape z ti)) (Program_statement (ndarray_program z) (Program___add__ (Program___add__ (Program___add__ (Program___init__ "assert " false) (ndarray_program z)) (Program___init__ ".shape == " false)) (tuple_int_program ti))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (assume_isfinite z)) (Program_statement (ndarray_program z) (Program___add__ (Program___add__ (Program___init__ "assert np.all(np.isfinite(" false) (ndarray_program z)) (Program___init__ "))" false))) :ruleset array_api_program_gen_ruleset) +(function tuple_value_program (TupleValue) Program) +(rewrite (ndarray_program (assume_value_one_of z tv)) (Program_statement (ndarray_program z) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "assert set(np.unique(" false) (ndarray_program z)) (Program___init__ ")) == set(" false)) (tuple_value_program tv)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(function Program_assign (Program) Program) +(rewrite (ndarray_program (reshape y ti ob)) (Program_assign (Program___add__ (Program___add__ (Program___add__ (ndarray_program y) (Program___init__ ".reshape(" false)) (tuple_int_program ti)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (astype y dtype)) (Program_assign (Program___add__ (Program___add__ (Program___add__ (ndarray_program y) (Program___init__ ".astype(" false)) (dtype_program dtype)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(function tuple_ndarray_program (TupleNDArray) Program) +(rewrite (tuple_ndarray_program (unique_counts x)) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.unique(" false) (ndarray_program x)) (Program___init__ ", return_counts=True)" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_ndarray_program (unique_inverse x)) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.unique(" false) (ndarray_program x)) (Program___init__ ", return_inverse=True)" false))) :ruleset array_api_program_gen_ruleset) +(function int_program (Int) Program) +(rewrite (ndarray_program (TupleNDArray___getitem__ tnd i)) (Program___add__ (Program___add__ (Program___add__ (tuple_ndarray_program tnd) (Program___init__ "[" false)) (int_program i)) (Program___init__ "]" false)) :ruleset array_api_program_gen_ruleset) +(function value_program (Value) Program) +(rewrite (ndarray_program (NDArray_scalar v)) (Program___add__ (Program___add__ (Program___init__ "np.array(" false) (value_program v)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (zeros ti %__expr_2091604061025500396 optional_device_)) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.zeros(" false) (tuple_int_program ti)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (zeros ti (OptionalDType_some dtype) optional_device_)) (Program_assign (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "np.zeros(" false) (tuple_int_program ti)) (Program___init__ ", dtype=" false)) (dtype_program dtype)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (unique_values x)) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.unique(" false) (ndarray_program x)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(function NDArray___add__ (NDArray NDArray) NDArray) +(rewrite (ndarray_program (NDArray___add__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " + " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (NDArray___sub__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " - " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (NDArray___mul__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " * " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (NDArray___truediv__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " / " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (NDArray___lt__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " < " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(function NDArray___le__ (NDArray NDArray) NDArray) +(rewrite (ndarray_program (NDArray___le__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " <= " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (NDArray___gt__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " > " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(function NDArray___ge__ (NDArray NDArray) NDArray) +(rewrite (ndarray_program (NDArray___ge__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " >= " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (NDArray___eq__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " == " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (NDArray___matmul__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " @ " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(function NDArray___mod__ (NDArray NDArray) NDArray) +(rewrite (ndarray_program (NDArray___mod__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " % " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(function NDArray___and__ (NDArray NDArray) NDArray) +(rewrite (ndarray_program (NDArray___and__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " & " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(function NDArray___or__ (NDArray NDArray) NDArray) +(rewrite (ndarray_program (NDArray___or__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " | " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(function NDArray___xor__ (NDArray NDArray) NDArray) +(rewrite (ndarray_program (NDArray___xor__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " ^ " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(function NDArray___lshift__ (NDArray NDArray) NDArray) +(rewrite (ndarray_program (NDArray___lshift__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " << " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(function NDArray___rshift__ (NDArray NDArray) NDArray) +(rewrite (ndarray_program (NDArray___rshift__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " >> " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(function NDArray___floordiv__ (NDArray NDArray) NDArray) +(rewrite (ndarray_program (NDArray___floordiv__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " // " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(function NDArray___pow__ (NDArray NDArray) NDArray) +(rewrite (ndarray_program (NDArray___pow__ x y)) (Program_assign (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ " ** " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(function index_key_program (IndexKey) Program) +(rewrite (ndarray_program (NDArray___setitem__ x idx y)) (Program_statement (Program_assign (ndarray_program x)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program_assign (ndarray_program x)) (Program___init__ "[" false)) (index_key_program idx)) (Program___init__ "] = " false)) (ndarray_program y))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (NDArray___getitem__ x idx)) (Program___add__ (Program___add__ (Program___add__ (ndarray_program x) (Program___init__ "[" false)) (index_key_program idx)) (Program___init__ "]" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (square x)) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.square(" false) (ndarray_program x)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (expand_dims x i)) (Program_assign (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "np.expand_dims(" false) (ndarray_program x)) (Program___init__ ", " false)) (int_program i)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (mean x %__expr_5981948135265815040 %__expr_6185990579165616281)) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.mean(" false) (ndarray_program x)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(function int_or_tuple_program (IntOrTuple) Program) +(rewrite (ndarray_program (mean x (OptionalIntOrTuple_some int_or_tuple_) %__expr_6185990579165616281)) (Program_assign (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "np.mean(" false) (ndarray_program x)) (Program___init__ ", axis=" false)) (int_or_tuple_program int_or_tuple_)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (mean x (OptionalIntOrTuple_some int_or_tuple_) (TRUE))) (Program_assign (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "np.mean(" false) (ndarray_program x)) (Program___init__ ", axis=" false)) (int_or_tuple_program int_or_tuple_)) (Program___init__ ", keepdims=True)" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (concat tnd %__expr_-143818766793636568)) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.concatenate(" false) (tuple_ndarray_program tnd)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (concat tnd (OptionalInt_some i))) (Program_assign (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "np.concatenate(" false) (tuple_ndarray_program tnd)) (Program___init__ ", axis=" false)) (int_program i)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (NDArray_vector tv)) (Program___add__ (Program___add__ (Program___init__ "np.array(" false) (tuple_value_program tv)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (std x %__expr_5981948135265815040)) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.std(" false) (ndarray_program x)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (std x (OptionalIntOrTuple_some int_or_tuple_))) (Program_assign (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "np.std(" false) (ndarray_program x)) (Program___init__ ", axis=" false)) (int_or_tuple_program int_or_tuple_)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_ndarray_program (svd x (TRUE))) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.linalg.svd(" false) (ndarray_program x)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_ndarray_program (svd x %__expr_6185990579165616281)) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.linalg.svd(" false) (ndarray_program x)) (Program___init__ ", full_matrices=False)" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (ndarray-sqrt x)) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.sqrt(" false) (ndarray_program x)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (NDArray_T x)) (Program___add__ (ndarray_program x) (Program___init__ ".T" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (sum x (OptionalIntOrTuple_none))) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.sum(" false) (ndarray_program x)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (sum x (OptionalIntOrTuple_some int_or_tuple_))) (Program_assign (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "np.sum(" false) (ndarray_program x)) (Program___init__ ", axis=" false)) (int_or_tuple_program int_or_tuple_)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_int_program (NDArray_shape x)) (Program___add__ (ndarray_program x) (Program___init__ ".shape" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (ndarray-abs x)) (Program_assign (Program___add__ (Program___add__ (Program___init__ "np.abs(" false) (ndarray_program x)) (Program___init__ ")" false))) :ruleset array_api_program_gen_ruleset) +(function optional_int_or_tuple_program (OptionalIntOrTuple) Program) +(rewrite (optional_int_or_tuple_program (OptionalIntOrTuple_some it)) (int_or_tuple_program it) :ruleset array_api_program_gen_ruleset) +(rewrite (optional_int_or_tuple_program %__expr_5981948135265815040) (Program___init__ "None" false) :ruleset array_api_program_gen_ruleset) +(rewrite (int_or_tuple_program (IntOrTuple_int x)) (int_program x) :ruleset array_api_program_gen_ruleset) +(function IntOrTuple_tuple (TupleInt) IntOrTuple) +(rewrite (int_or_tuple_program (IntOrTuple_tuple t)) (tuple_int_program t) :ruleset array_api_program_gen_ruleset) +(function IndexKey_ELLIPSIS () IndexKey) +(rewrite (index_key_program (IndexKey_ELLIPSIS)) (Program___init__ "..." false) :ruleset array_api_program_gen_ruleset) +(rewrite (index_key_program (IndexKey_int i)) (int_program i) :ruleset array_api_program_gen_ruleset) +(function slice_program (Slice) Program) +(rewrite (index_key_program (IndexKey_slice s)) (slice_program s) :ruleset array_api_program_gen_ruleset) +(function multi_axis_index_key_program (MultiAxisIndexKey) Program) +(rewrite (index_key_program (IndexKey_multi_axis key)) (multi_axis_index_key_program key) :ruleset array_api_program_gen_ruleset) +(rewrite (index_key_program (IndexKey_ndarray a)) (ndarray_program a) :ruleset array_api_program_gen_ruleset) +(sort UnstableFn_MultiAxisIndexKeyItem_Int (UnstableFn (Int) MultiAxisIndexKeyItem)) +(function idx_fn-UnstableFn_MultiAxisIndexKeyItem_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___ (UnstableFn_MultiAxisIndexKeyItem_Int Int) MultiAxisIndexKeyItem) +(rewrite (idx_fn-UnstableFn_MultiAxisIndexKeyItem_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___ idx_fn i) (unstable-app idx_fn (Int___add__ i (Int___init__ 1))) :ruleset array_api_program_gen_ruleset) +(function MultiAxisIndexKey___init__ (Int UnstableFn_MultiAxisIndexKeyItem_Int) MultiAxisIndexKey) +(rewrite (multi_axis_index_key_program (MultiAxisIndexKey___init__ %__expr_-7942988945600443502 idx_fn)) (Program___init__ "" false) :ruleset array_api_program_gen_ruleset) +(function multi_axis_index_key_item_program (MultiAxisIndexKeyItem) Program) +(rewrite (multi_axis_index_key_program (MultiAxisIndexKey___init__ (Int___init__ k) idx_fn)) (Program___add__ (Program___add__ (multi_axis_index_key_item_program (unstable-app idx_fn %__expr_-7942988945600443502)) (Program___init__ ", " false)) (multi_axis_index_key_program (MultiAxisIndexKey___init__ (Int___init__ (- k 1)) (unstable-fn "idx_fn-UnstableFn_MultiAxisIndexKeyItem_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___" idx_fn)))) :when ((!= k 0)) :ruleset array_api_program_gen_ruleset) +(rewrite (multi_axis_index_key_program (MultiAxisIndexKey_from_vec (vec-of))) (Program___init__ "" false) :ruleset array_api_program_gen_ruleset) +(rewrite (multi_axis_index_key_program (MultiAxisIndexKey_from_vec vec)) (Program___add__ (multi_axis_index_key_item_program (vec-get vec %__expr_-1580149342035447281)) (Program___init__ "," false)) :when ((= (vec-length vec) %__expr_-8085216922850384227)) :ruleset array_api_program_gen_ruleset) +(rewrite (multi_axis_index_key_program (MultiAxisIndexKey_from_vec vec)) (Program___add__ (Program___add__ (multi_axis_index_key_item_program (vec-get vec %__expr_-1580149342035447281)) (Program___init__ ", " false)) (multi_axis_index_key_program (MultiAxisIndexKey_from_vec (vec-remove vec %__expr_-1580149342035447281)))) :when ((> (vec-length vec) %__expr_-8085216922850384227)) :ruleset array_api_program_gen_ruleset) +(rewrite (multi_axis_index_key_item_program (MultiAxisIndexKeyItem_int i)) (int_program i) :ruleset array_api_program_gen_ruleset) +(rewrite (multi_axis_index_key_item_program (MultiAxisIndexKeyItem_slice s)) (slice_program s) :ruleset array_api_program_gen_ruleset) +(function MultiAxisIndexKeyItem_ELLIPSIS () MultiAxisIndexKeyItem) +(rewrite (multi_axis_index_key_item_program (MultiAxisIndexKeyItem_ELLIPSIS)) (Program___init__ "..." false) :ruleset array_api_program_gen_ruleset) +(function MultiAxisIndexKeyItem_NONE () MultiAxisIndexKeyItem) +(rewrite (multi_axis_index_key_item_program (MultiAxisIndexKeyItem_NONE)) (Program___init__ "None" false) :ruleset array_api_program_gen_ruleset) +(function optional_int_slice_program (OptionalInt) Program) +(rewrite (slice_program (Slice___init__ start stop %__expr_-143818766793636568)) (Program___add__ (Program___add__ (optional_int_slice_program start) (Program___init__ ":" false)) (optional_int_slice_program stop)) :ruleset array_api_program_gen_ruleset) +(rewrite (slice_program (Slice___init__ start stop (OptionalInt_some i))) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (optional_int_slice_program start) (Program___init__ ":" false)) (optional_int_slice_program stop)) (Program___init__ ":" false)) (int_program i)) :ruleset array_api_program_gen_ruleset) +(rewrite (optional_int_slice_program %__expr_-143818766793636568) (Program___init__ "" false) :ruleset array_api_program_gen_ruleset) +(rewrite (optional_int_slice_program (OptionalInt_some x)) (int_program x) :ruleset array_api_program_gen_ruleset) +(function optional_int_program (OptionalInt) Program) +(rewrite (optional_int_program %__expr_-143818766793636568) (Program___init__ "None" false) :ruleset array_api_program_gen_ruleset) +(rewrite (optional_int_program (OptionalInt_some x)) (int_program x) :ruleset array_api_program_gen_ruleset) +(function optional_dtype_program (OptionalDType) Program) +(rewrite (optional_dtype_program %__expr_2091604061025500396) (Program___init__ "None" false) :ruleset array_api_program_gen_ruleset) +(rewrite (optional_dtype_program (OptionalDType_some dtype)) (dtype_program dtype) :ruleset array_api_program_gen_ruleset) +(function tuple_ndarray_program_inner (TupleNDArray) Program) +(rewrite (tuple_ndarray_program r) (Program___add__ (Program___add__ (Program___init__ "(" false) (tuple_ndarray_program_inner r)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_ndarray_program_inner (TupleNDArray___init__ x)) (Program___add__ (ndarray_program x) (Program___init__ "," false)) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_ndarray_program_inner (TupleNDArray___add__ l r)) (Program___add__ (Program___add__ (tuple_ndarray_program_inner l) (Program___init__ " " false)) (tuple_ndarray_program_inner r)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (TupleNDArray_length l)) (Program___add__ (Program___add__ (Program___init__ "len(" false) (tuple_ndarray_program l)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (ndarray_program (TupleNDArray___getitem__ l i)) (Program___add__ (Program___add__ (Program___add__ (tuple_ndarray_program l) (Program___init__ "[" false)) (int_program i)) (Program___init__ "]" false)) :ruleset array_api_program_gen_ruleset) +(function tuple_value_program_inner (TupleValue) Program) +(rewrite (tuple_value_program tv1) (Program___add__ (Program___add__ (Program___init__ "(" false) (tuple_value_program_inner tv1)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_value_program_inner (TupleValue___add__ tv1 tv2)) (Program___add__ (Program___add__ (tuple_value_program_inner tv1) (Program___init__ " " false)) (tuple_value_program_inner tv2)) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_value_program_inner (TupleValue___init__ v)) (Program___add__ (value_program v) (Program___init__ "," false)) :ruleset array_api_program_gen_ruleset) +(rewrite (value_program (Value_int i)) (int_program i) :ruleset array_api_program_gen_ruleset) +(function bool_program (Boolean) Program) +(rewrite (value_program (Value_bool b)) (bool_program b) :ruleset array_api_program_gen_ruleset) +(function float_program (Float) Program) +(rewrite (value_program (Value_float f)) (float_program f) :ruleset array_api_program_gen_ruleset) +(rewrite (value_program (NDArray_to_value x)) (ndarray_program x) :ruleset array_api_program_gen_ruleset) +(rewrite (value_program (Value___lt__ v1 v2)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (value_program v1)) (Program___init__ " < " false)) (value_program v2)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (value_program (Value___truediv__ v1 v2)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (value_program v1)) (Program___init__ " / " false)) (value_program v2)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (bool_program (Value_to_bool v1)) (value_program v1) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Value_to_int v1)) (value_program v1) :ruleset array_api_program_gen_ruleset) +(rewrite (float_program (Float___init__ f64_)) (Program___init__ (to-string f64_) false) :ruleset array_api_program_gen_ruleset) +(rewrite (float_program (Float_abs f)) (Program___add__ (Program___add__ (Program___init__ "np.abs(" false) (float_program f)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (float_program (Float_from_int i)) (int_program i) :ruleset array_api_program_gen_ruleset) +(rewrite (float_program (Float___add__ f g)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (float_program f)) (Program___init__ " + " false)) (float_program g)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (float_program (Float___sub__ f g)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (float_program f)) (Program___init__ " - " false)) (float_program g)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (float_program (Float___mul__ f g)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (float_program f)) (Program___init__ " * " false)) (float_program g)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (float_program (Float___truediv__ f g)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (float_program f)) (Program___init__ " / " false)) (float_program g)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (float_program (Float_rational r)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "float(" false) (Program___init__ (to-string (numer r)) false)) (Program___init__ " / " false)) (Program___init__ (to-string (denom r)) false)) (Program___init__ ")" false)) :when ((!= (denom r) %__expr_-8085216922850384227)) :ruleset array_api_program_gen_ruleset) +(rewrite (float_program (Float_rational r)) (Program___add__ (Program___add__ (Program___init__ "float(" false) (Program___init__ (to-string (numer r)) false)) (Program___init__ ")" false)) :when ((= (denom r) %__expr_-8085216922850384227)) :ruleset array_api_program_gen_ruleset) +(rewrite (dtype_program %__expr_2565664028803046192) (Program___init__ "np.dtype(np.float64)" false) :ruleset array_api_program_gen_ruleset) +(rewrite (dtype_program (DType_float32)) (Program___init__ "np.dtype(np.float32)" false) :ruleset array_api_program_gen_ruleset) +(rewrite (dtype_program (DType_int64)) (Program___init__ "np.dtype(np.int64)" false) :ruleset array_api_program_gen_ruleset) +(rewrite (dtype_program %__expr_-3501279694271260104) (Program___init__ "np.dtype(np.int32)" false) :ruleset array_api_program_gen_ruleset) +(rewrite (dtype_program (DType_bool)) (Program___init__ "np.dtype(np.bool)" false) :ruleset array_api_program_gen_ruleset) +(rewrite (dtype_program (DType_object)) (Program___init__ "np.dtype(np.object_)" false) :ruleset array_api_program_gen_ruleset) +(rewrite (idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___ idx_fn i) (unstable-app idx_fn (Int___add__ i (Int___init__ 1))) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (TupleInt___getitem__ ti i)) (Program___add__ (Program___add__ (Program___add__ (tuple_int_program ti) (Program___init__ "[" false)) (int_program i)) (Program___init__ "]" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (TupleInt_length ti)) (Program___add__ (Program___add__ (Program___init__ "len(" false) (tuple_int_program ti)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(function tuple_int_program_inner (TupleInt) Program) +(rewrite (tuple_int_program ti) (Program___add__ (Program___add__ (Program___init__ "(" false) (tuple_int_program_inner ti)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_int_program_inner (TupleInt___init__ (Int___init__ 0) idx_fn)) (Program___init__ "" false) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_int_program_inner (TupleInt___init__ (Int___init__ k) idx_fn)) (Program___add__ (Program___add__ (int_program (unstable-app idx_fn (Int___init__ 0))) (Program___init__ ", " false)) (tuple_int_program_inner (TupleInt___init__ (Int___init__ (- k 1)) (unstable-fn "idx_fn-UnstableFn_Int_Int_i-Int__unstable-app_idx_fn__Int___add___i__Int___init___1___" idx_fn)))) :when ((!= k 0)) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_int_program_inner (TupleInt_from_vec (vec-of))) (Program___init__ "" false) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_int_program_inner (TupleInt_from_vec vec_int)) (Program___add__ (Program___add__ (int_program (vec-get vec_int %__expr_-1580149342035447281)) (Program___init__ ", " false)) (tuple_int_program_inner (TupleInt_from_vec (vec-remove vec_int %__expr_-1580149342035447281)))) :when ((> (vec-length vec_int) %__expr_-8085216922850384227)) :ruleset array_api_program_gen_ruleset) +(rewrite (tuple_int_program_inner (TupleInt_from_vec vec_int)) (Program___add__ (int_program (vec-get vec_int %__expr_-1580149342035447281)) (Program___init__ "," false)) :when ((= (vec-length vec_int) %__expr_-8085216922850384227)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___init__ i64_)) (Program___init__ (to-string i64_) false) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___invert__ i)) (Program___add__ (Program___init__ "~" false) (int_program i)) :ruleset array_api_program_gen_ruleset) +(rewrite (bool_program (Int___lt__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " < " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(function Int___le__ (Int Int) Boolean) +(rewrite (bool_program (Int___le__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " <= " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (bool_program (Int___gt__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " > " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (bool_program (Int___ge__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " >= " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (bool_program (Int___eq__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " == " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___add__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " + " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___sub__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " - " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___mul__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " * " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___truediv__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " / " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___mod__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " % " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(function Int___pow__ (Int Int) Int) +(rewrite (int_program (Int___pow__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " ** " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___and__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " & " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___or__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " | " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___xor__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " ^ " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___lshift__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " << " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (int_program (Int___rshift__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " >> " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(function Int___floordiv__ (Int Int) Int) +(rewrite (int_program (Int___floordiv__ i j)) (Program___add__ (Program___add__ (Program___add__ (Program___add__ (Program___init__ "(" false) (int_program i)) (Program___init__ " // " false)) (int_program j)) (Program___init__ ")" false)) :ruleset array_api_program_gen_ruleset) +(rewrite (bool_program (TRUE)) (Program___init__ "True" false) :ruleset array_api_program_gen_ruleset) +(rewrite (bool_program %__expr_6185990579165616281) (Program___init__ "False" false) :ruleset array_api_program_gen_ruleset) +(ruleset program_gen_ruleset) +(function Program_expr (Program) String) +(function Program_statements (Program) String) +(function Program_next_sym (Program) i64) +(function Program_is_identifer (Program) bool) +(rule ((= p (Program___init__ s b)) + (Program_compile p i)) + ((set (Program_expr p) s) + (set (Program_statements p) "") + (set (Program_next_sym p) i) + (set (Program_is_identifer p) b)) + :ruleset program_gen_ruleset ) +(function Program_expr_to_statement (Program) Program) +(rewrite (Program_statement p1 p2) (Program___add__ p1 (Program_expr_to_statement p2)) :ruleset program_gen_ruleset) +(function Program_parent (Program) Program :unextractable :merge old) +(rule ((= p (Program_expr_to_statement p1)) + (Program_compile p i)) + ((set (Program_parent p1) p) + (set (Program_is_identifer p) false)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program_expr_to_statement p1)) + (Program_compile p i) + (= (Program_parent p1) p)) + ((Program_compile p1 i)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program_expr_to_statement p1)) + (Program_compile p i) + (!= (Program_parent p1) p) + (= s1 (Program_expr p1))) + ((set (Program_statements p) (+ s1 " +")) + (set (Program_next_sym p) i) + (set (Program_expr p) "")) + :ruleset program_gen_ruleset ) +(rule ((= p (Program_expr_to_statement p1)) + (= (Program_parent p1) p) + (= s1 (Program_expr p1)) + (= s2 (Program_statements p1)) + (= i (Program_next_sym p1))) + ((set (Program_statements p) (+ s2 s1 " +")) + (set (Program_next_sym p) i) + (set (Program_expr p) "")) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (= (Program_expr p) (Program_expr p1)) + (= b (Program_is_identifer p1))) + ((set (Program_is_identifer p) b)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (= (Program_expr p) (Program_expr p2)) + (= b (Program_is_identifer p2))) + ((set (Program_is_identifer p) b)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (!= (Program_expr p) (Program_expr p1)) + (!= (Program_expr p) (Program_expr p2))) + ((set (Program_is_identifer p) false)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (Program_compile p i)) + ((set (Program_parent p1) p)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (Program_compile p i) + (= (Program_parent p1) p)) + ((Program_compile p1 i)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (Program_compile p i) + (Program_next_sym p1)) + ((set (Program_parent p2) p)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (Program_compile p i) + (!= (Program_parent p1) p) + (= (Program_parent p2) p)) + ((Program_compile p2 i)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (Program_compile p i2) + (= (Program_parent p1) p) + (= i (Program_next_sym p1)) + (= (Program_parent p2) p)) + ((Program_compile p2 i)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (= s1 (Program_expr p1)) + (= s2 (Program_expr p2))) + ((set (Program_expr p) (+ s1 s2))) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (= (Program_parent p1) p) + (= (Program_parent p2) p) + (= s1 (Program_statements p1)) + (= s2 (Program_statements p2)) + (= i (Program_next_sym p2))) + ((set (Program_statements p) (+ s1 s2)) + (set (Program_next_sym p) i)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (Program_compile p i) + (!= (Program_parent p1) p) + (!= (Program_parent p2) p)) + ((set (Program_statements p) "") + (set (Program_next_sym p) i)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (= (Program_parent p1) p) + (!= (Program_parent p2) p) + (= s1 (Program_statements p1)) + (= i (Program_next_sym p1))) + ((set (Program_statements p) s1) + (set (Program_next_sym p) i)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program___add__ p1 p2)) + (= (Program_parent p2) p) + (!= (Program_parent p1) p) + (= s2 (Program_statements p2)) + (= i (Program_next_sym p2))) + ((set (Program_statements p) s2) + (set (Program_next_sym p) i)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program_assign p1)) + (Program_compile p i)) + ((set (Program_parent p1) p) + (set (Program_is_identifer p) true)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program_assign p1)) + (Program_compile p i) + (= (Program_parent p1) p)) + ((Program_compile p1 i)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program_assign p1)) + (= (Program_parent p1) p) + (= s1 (Program_statements p1)) + (= i (Program_next_sym p1)) + (= s2 (Program_expr p1)) + (= (Program_is_identifer p1) false)) + ((set (Program_statements p) (+ s1 (+ "_" (to-string i)) " = " s2 " +")) + (set (Program_expr p) (+ "_" (to-string i))) + (set (Program_next_sym p) (+ i %__expr_-8085216922850384227))) + :ruleset program_gen_ruleset ) +(rule ((= p (Program_assign p1)) + (!= (Program_parent p1) p) + (Program_compile p i) + (= s2 (Program_expr p1)) + (= (Program_is_identifer p1) false)) + ((set (Program_statements p) (+ (+ "_" (to-string i)) " = " s2 " +")) + (set (Program_expr p) (+ "_" (to-string i))) + (set (Program_next_sym p) (+ i %__expr_-8085216922850384227))) + :ruleset program_gen_ruleset ) +(rule ((= p (Program_assign p1)) + (= (Program_parent p1) p) + (= s1 (Program_statements p1)) + (= i (Program_next_sym p1)) + (= s2 (Program_expr p1)) + (= (Program_is_identifer p1) true)) + ((set (Program_statements p) s1) + (set (Program_expr p) s2) + (set (Program_next_sym p) i)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program_assign p1)) + (!= (Program_parent p1) p) + (Program_compile p i) + (= s2 (Program_expr p1)) + (= (Program_is_identifer p1) true)) + ((set (Program_statements p) "") + (set (Program_expr p) s2) + (set (Program_next_sym p) i)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program_function_two p1 p2 p3 s1)) + (Program_compile p i)) + ((set (Program_parent p2) p) + (set (Program_parent p3) p) + (set (Program_parent p1) p) + (Program_compile p2 i) + (Program_compile p3 i) + (Program_compile p1 i) + (set (Program_is_identifer p) true)) + :ruleset program_gen_ruleset ) +(rule ((= p (Program_function_two p1 p2 p3 s1)) + (Program_compile p i) + (= s2 (Program_expr p1)) + (= s3 (Program_statements p1)) + (= s4 (Program_expr p2)) + (= s5 (Program_expr p3))) + ((set (Program_statements p) (+ "def " s1 "(" s4 ", " s5 "): + " (replace s3 " +" " + ") "return " s2 " +")) + (set (Program_next_sym p) i) + (set (Program_expr p) s1)) + :ruleset program_gen_ruleset ) +(run-schedule (seq (saturate (run array_api_program_gen_ruleset)) (saturate (run program_gen_ruleset)))) +(let %__expr_-116196252424162806 (assume_dtype (NDArray_var "X") (DType_float64))) +(extract (Program_statements (ndarray_function_two_program (NDArray___getitem__ (NDArray___matmul__ (NDArray___sub__ %__expr_978886785202701864 %__expr_4447619498771141281) (NDArray___matmul__ %__expr_-6562228218073754698 (NDArray___getitem__ (NDArray_T (TupleNDArray___getitem__ %__expr_-4464433185064523998 %__expr_2305922367412063525)) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of %__expr_-8637348939342624324 (MultiAxisIndexKeyItem_slice (Slice___init__ %__expr_-143818766793636568 (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ %__expr_2615935926139764667 (NDArray___mul__ %__expr_-4180228001421012884 (NDArray___getitem__ %__expr_2615935926139764667 %__expr_4326809257670680665))) %__expr_-3501279694271260104) %__expr_5981948135265815040)))) %__expr_-143818766793636568)))))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of %__expr_-8637348939342624324 (MultiAxisIndexKeyItem_slice (Slice___init__ %__expr_-143818766793636568 (OptionalInt_some %__expr_2305922367412063525) %__expr_-143818766793636568)))))) (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))))) 0) diff --git a/tests/rational.egg b/tests/rational.egg new file mode 100644 index 0000000..af7cae7 --- /dev/null +++ b/tests/rational.egg @@ -0,0 +1,14 @@ +; Test that can run rule matching on rational + +(datatype Pretty + (pretty-str String) + (pretty-rational Rational)) + +; This will fail with `Unbound variable x in primitive computation` currently: +; (rewrite (pretty-rational (rational x y)) (pretty-str (+ (to-string x) "/" (to-string y)))) + +(rewrite (pretty-rational r) (pretty-str (+ (to-string (numer r)) "/" (to-string (denom r))))) + +(let z (pretty-rational (rational 1 2))) +(run 1) +(check (= z (pretty-str "1/2"))) diff --git a/tests/repro-define.egg b/tests/repro-define.egg new file mode 100644 index 0000000..1c2d8cd --- /dev/null +++ b/tests/repro-define.egg @@ -0,0 +1,9 @@ +(datatype Nat + (S Nat)) +(function ZeroConst () Nat) +(let Zero (ZeroConst)) + +(let two (S (S Zero))) + +(union two (S (S (S Zero)))) +(check (= two (S (S (S Zero))))) diff --git a/tests/repro-desugar-143.egg b/tests/repro-desugar-143.egg new file mode 100644 index 0000000..7a07854 --- /dev/null +++ b/tests/repro-desugar-143.egg @@ -0,0 +1,40 @@ +;; To test on issue #143 +(rule ((= x 1) (= y x)) ()) +(rule ((= x 1) (= y x) (= z y)) ()) + +(function f (i64) i64) + +(set (f 0) 0) + +;; a funky id rule +(rule ((f x) (= x y) (= z y)) ((let a (f z)) (set (f (+ z 1)) (+ a 1)))) + +(run 20) + +(print-function f 100) +(check (= (f 10) 10)) + +(datatype Value (Num i64)) +(function fib (Value) Value) + +;; a funky fibonacci that test on more complex case and user defined datatype +(rule ((= (Num a) (fib (Num x))) + (= (Num b) (fib (Num y))) + (= x1 x) + (= y1 y) + (= a1 a) + (= b1 b) + (= x1 x2) + (= y1 y2) + (= a1 a2) + (= b1 b2) + (= 1 (- x2 y2))) + ((let n (+ x 1)) (let sum (+ a1 b2)) (union (fib (Num n)) (Num sum)))) + +(union (fib (Num 1)) (Num 1)) +(union (fib (Num 2)) (Num 1)) + +(run 20) + +(print-function fib 100) +(check (= (fib (Num 10)) (Num 55))) diff --git a/tests/repro-empty-query.egg b/tests/repro-empty-query.egg new file mode 100644 index 0000000..30bc567 --- /dev/null +++ b/tests/repro-empty-query.egg @@ -0,0 +1,9 @@ +(function foo () i64 :merge (min old new)) + +(rule () ((set (foo) 4))) + +(set (foo) 10) + +(run 3) + +(check (= (foo) 4)) \ No newline at end of file diff --git a/tests/repro-equal-constant.egg b/tests/repro-equal-constant.egg new file mode 100644 index 0000000..6dd8154 --- /dev/null +++ b/tests/repro-equal-constant.egg @@ -0,0 +1,9 @@ +(function foo () i64 :merge (min old new)) + +(rule ((= (foo) 5)) ((set (foo) 4))) + +(set (foo) 10) + +(run 3) + +(check (!= (foo) 4)) \ No newline at end of file diff --git a/tests/repro-equal-constant2.egg b/tests/repro-equal-constant2.egg new file mode 100644 index 0000000..dd72dd3 --- /dev/null +++ b/tests/repro-equal-constant2.egg @@ -0,0 +1,9 @@ +(function foo () i64 :merge (min old new)) + +(rule ((= (foo) 10)) ((set (foo) 4))) + +(set (foo) 10) + +(run 3) + +(check (= (foo) 4)) \ No newline at end of file diff --git a/tests/repro-noteqbug.egg b/tests/repro-noteqbug.egg new file mode 100644 index 0000000..5052e18 --- /dev/null +++ b/tests/repro-noteqbug.egg @@ -0,0 +1,11 @@ +(datatype r (R i64)) +(union (R 1) (R 2)) + +(check (= (R 1) (R 2))) +(fail (check (!= (R 1) (R 2)))) + +(run 0) + + +(check (= (R 1) (R 2))) +(fail (check (!= (R 1) (R 2)))) diff --git a/tests/repro-primitive-query.egg b/tests/repro-primitive-query.egg new file mode 100644 index 0000000..ebe4443 --- /dev/null +++ b/tests/repro-primitive-query.egg @@ -0,0 +1,12 @@ +(datatype Math + (Num i64)) + +(Num 1) +(Num 2) + +(rule ((Num ?a) + (Num ?b) + (= (+ ?a ?b) 5)) + ((panic "should not have matched"))) + +(run 100) \ No newline at end of file diff --git a/tests/repro-querybug.egg b/tests/repro-querybug.egg new file mode 100644 index 0000000..3c9e0c0 --- /dev/null +++ b/tests/repro-querybug.egg @@ -0,0 +1,17 @@ +(datatype list + (Cons i64 list)) +(function EmptyConst () list) +(let Empty (EmptyConst)) + +(relation eq (list list)) + +(eq Empty Empty) + +; Oddly, this version works: +; (rule ((= x (Cons x1 rest1)) (= y (Cons x2 rest2)) (= 0 (- x1 x2)) (eq rest1 rest2)) +(rule ((= x (Cons x1 rest1)) (= y (Cons x2 rest2)) (= x1 x2) (eq rest1 rest2)) + ((eq (Cons x1 rest1) (Cons x2 rest2)))) + +(let mylist (Cons 1 Empty)) + +(run 100) diff --git a/tests/repro-querybug2.egg b/tests/repro-querybug2.egg new file mode 100644 index 0000000..1d1f8de --- /dev/null +++ b/tests/repro-querybug2.egg @@ -0,0 +1,15 @@ +(datatype Nat + (Num i64) + (OtherNum i64)) + + + +(rule ((= y 2)) + ((union (OtherNum y) (Num y)))) + +(Num 2) + + +(run 100) + +(check (= (OtherNum 2) (Num 2))) diff --git a/tests/repro-querybug3.egg b/tests/repro-querybug3.egg new file mode 100644 index 0000000..11f8b53 --- /dev/null +++ b/tests/repro-querybug3.egg @@ -0,0 +1,31 @@ +(datatype VarT) +(datatype Term) +(function App (Term Term) Term) +(function Lam (VarT Term) Term) +(function Var (VarT) Term) +(function Let (VarT Term Term) Term) +(function Add (Term Term) Term) +(function Num (i64) Term) +(function CaseSplit (Term Term Term) Term) +(function Cons (Term Term) Term) +(function Nil () Term) +(function V (String) VarT) +(sort StringSet (Set VarT)) +(function freer (Term) StringSet :merge (set-intersect old new)) + +;;(rule ((= e (App e1 e2)) +;; (= (freer e1) fv1) +;; (= (freer e2) fv2)) +;; ((set (freer e) (set-union fv1 fv2)))) + +(rule ((= e (App e1 e2)) + (= fvar1 (freer e1)) + (= fvar1 fv1) + (= fvar2 (freer e2)) + (= fvar2 fv2)) + ((set (freer e) (set-union fv1 fv2)))) +(rule ((= e (Var v))) ((set (freer e) (set-insert (set-empty) v)))) +(function sum () Term :cost 1000) +(union (sum) (Lam (V "xs") (CaseSplit (Var (V "xs")) (Num 0) (Lam (V "x") (Lam (V "xs'") (Add (Var (V "x")) (App (sum) (Var (V "xs'"))))))))) +(set (freer (sum)) (set-empty)) +(run 100) diff --git a/tests/repro-querybug4.egg b/tests/repro-querybug4.egg new file mode 100644 index 0000000..d00045f --- /dev/null +++ b/tests/repro-querybug4.egg @@ -0,0 +1,9 @@ +(sort Nat) +(function Num (i64) Nat) +(function OtherNum (i64) Nat) +(rule ((= fvar5__ 2) (= fvar6__ fvar5__) (= y fvar5__)) + ((union (OtherNum fvar5__) (Num fvar5__)))) + +(Num 2) +(run 100) +(check (= (OtherNum 2) (Num 2))) \ No newline at end of file diff --git a/tests/repro-should-saturate.egg b/tests/repro-should-saturate.egg new file mode 100644 index 0000000..74c38a1 --- /dev/null +++ b/tests/repro-should-saturate.egg @@ -0,0 +1,10 @@ + +(function MyMap () i64 :merge (min old new)) + +(set (MyMap) 1) + +(rule ((MyMap)) + ((set (MyMap) 1) + (set (MyMap) 2))) + +(run-schedule (saturate (run))) diff --git a/tests/repro-silly-panic.egg b/tests/repro-silly-panic.egg new file mode 100644 index 0000000..789ebe3 --- /dev/null +++ b/tests/repro-silly-panic.egg @@ -0,0 +1,12 @@ +(datatype KAT + (par KAT KAT) +) +(function AConst () KAT) +(let A (AConst)) + +(rewrite (par p p) p) +(rule ((= r (par q r)) (= q (par q r))) ((union r q))) + +; tests +(let q (par A A)) +(run 10) \ No newline at end of file diff --git a/tests/repro-typechecking-schedule.egg b/tests/repro-typechecking-schedule.egg new file mode 100644 index 0000000..cabe90d --- /dev/null +++ b/tests/repro-typechecking-schedule.egg @@ -0,0 +1,6 @@ +(rule () ()) + +;; This should type check +(run-schedule + (seq (run :until (= a 1)) + (run :until (= a "s")))) diff --git a/tests/repro-unsound-htutorial.egg b/tests/repro-unsound-htutorial.egg new file mode 100644 index 0000000..fcf1031 --- /dev/null +++ b/tests/repro-unsound-htutorial.egg @@ -0,0 +1,16 @@ +(datatype Math + (Num Rational) + (Var String) + (Add Math Math) + (Div Math Math) + (Mul Math Math)) + +(let z (Var "z")) + +(Add (Var "x") (Var "y")) + +(rewrite (Add a z) a) + +(run 2) + +(fail (check (= (Var "x") (Add (Var "x") (Var "y"))))) \ No newline at end of file diff --git a/tests/repro-unsound.egg b/tests/repro-unsound.egg new file mode 100644 index 0000000..a3127af --- /dev/null +++ b/tests/repro-unsound.egg @@ -0,0 +1,63 @@ + +(datatype HerbieType (Type String)) +(datatype Math (Num HerbieType Rational) (Var HerbieType String) (Fma HerbieType Math Math Math) (If HerbieType Math Math Math) (Less HerbieType Math Math) (LessEq HerbieType Math Math) (Greater HerbieType Math Math) (GreaterEq HerbieType Math Math) (Eq HerbieType Math Math) (NotEq HerbieType Math Math) (Add HerbieType Math Math) (Sub HerbieType Math Math) (Mul HerbieType Math Math) (Div HerbieType Math Math) (Pow HerbieType Math Math) (Atan2 HerbieType Math Math) (Hypot HerbieType Math Math) (And HerbieType Math Math) (Or HerbieType Math Math) (Not HerbieType Math) (Neg HerbieType Math) (Sqrt HerbieType Math) (Cbrt HerbieType Math) (Fabs HerbieType Math) (Ceil HerbieType Math) (Floor HerbieType Math) (Round HerbieType Math) (Log HerbieType Math) (Exp HerbieType Math) (Sin HerbieType Math) (Cos HerbieType Math) (Tan HerbieType Math) (Atan HerbieType Math) (Asin HerbieType Math) (Acos HerbieType Math) (Expm1 HerbieType Math) (Log1p HerbieType Math) (Sinh HerbieType Math) (Cosh HerbieType Math) (Tanh HerbieType Math) (PI HerbieType) (E HerbieType) (INFINITY HerbieType) (TRUE HerbieType) (FALSE HerbieType)) +(let r-zero (rational 0 1)) +(let r-one (rational 1 1)) +(let r-two (rational 2 1)) +(let r-three (rational 3 1)) +(let r-four (rational 4 1)) +(let r-neg-one (rational -1 1)) +(relation universe (Math HerbieType)) +(rule ((= t (Expm1 ty a))) ((universe t ty))) +(rewrite (Mul ty a b) (Mul ty b a)) + +(rewrite (Sub ty x x) (Num ty r-zero)) + +(rewrite (Mul ty x (Num ty r-one)) x) + +(rewrite (Div ty x (Num ty r-one)) x) + +(rewrite (Neg ty x) (Sub ty (Num ty r-zero) x)) + +(rewrite (Neg ty x) (Mul ty (Num ty r-neg-one) x)) + +(rule ((universe t ty)) ((union t (Mul ty (Num ty r-one) t)))) + +(rewrite (Div ty (Sub ty a b) c) + (Sub ty (Div ty a c) (Div ty b c))) + + +(rewrite (Div ty (Mul ty a b) (Mul ty c d)) ;; not defined if c or d is zero + (Mul ty (Div ty a c) (Div ty b d))) + + +;; errors if a or b errors +(rewrite (Add ty a b) + (If ty + (NotEq ty (Sub ty a b) (Num ty r-zero)) ;; errors if a or b errors + (Div ty + (Sub ty (Mul ty a a) (Mul ty b b)) + (Sub ty a b)) + (Add ty a b))) + + +(rewrite (Sub ty (Div ty a b) (Div ty c d)) ;; errors when b = 0 or d = 0 + (Div ty (Sub ty (Mul ty a d) (Mul ty b c)) + (Mul ty b d))) ;; errors when b = 0 or d = 0 + + +(rewrite (Sub ty (Mul ty x y) z) + (Fma ty x y (Neg ty z))) + + +(rewrite (Expm1 ty x) + (Sub ty (Exp ty x) (Num ty r-one))) + + + + +(let eggvar1 (Div (Type "binary64") (Expm1 (Type "binary64") (Add (Type "binary64") (Var (Type "binary64") "h0") (Var (Type "binary64") "h0"))) (Expm1 (Type "binary64") (Var (Type "binary64") "h0")))) + +(run 10) + +(check (= (Num ty n) (Num ty m)) (!= n m)) diff --git a/tests/repro-vec-unequal.egg b/tests/repro-vec-unequal.egg new file mode 100644 index 0000000..1ffaab6 --- /dev/null +++ b/tests/repro-vec-unequal.egg @@ -0,0 +1,17 @@ +(datatype Math + (Num i64)) + +(sort MathVec (Vec Math)) + +(let v1 (vec-of (Num 1) (Num 2))) +(let v2 (vec-of (Num 2) (Num 2))) + +(fail (check (= v1 v2))) + + +(sort IVec (Vec i64)) + +(let v3 (vec-of 1 2)) +(let v4 (vec-of 2 2)) + +(fail (check (= v3 v4))) \ No newline at end of file diff --git a/tests/resolution.egg b/tests/resolution.egg new file mode 100644 index 0000000..974958c --- /dev/null +++ b/tests/resolution.egg @@ -0,0 +1,101 @@ +; Resolution theorem proving +; +; Traditional resolution theorem provers maintain a clause database +; of formulas in Conjunction Normal Form (CNF a big And of Ors). +; Each clause is a set of positive and negative literals +; The prover saturates this set by taking two clauses +; {a}\/c1 {not a}\/c2 and creating a new clause c1 \/ c2. +; Clauses also are pruned by simplications, unit propagation, +; and subsumption. +; These systems use sophisticated term indexing to find matching clauses + +; A natural question is whether egglog's saturation and term indexing gives +; a leg up towards building one of these systems. A programmable one even, +; with built in support for equality reasoning + +; Resolution is provided by a join +; unit propagation is an equation solving process and egraph substitution +; Clause Simplification is provided by rewrite rules + +; This encoding seems about right but is unsatisfying +; Using AC to encode the set nature of clauses is inefficient + +; An important aspect of these provers that seems challenging to encode shallowly +; is that the match also occurs modulo _unification_. +; The unification variables of each clause are not globally scoped, really +; they are scoped outside the body of each clase in an implicit \forall +; This encoding as it stands really only supports ground atoms modulo equality + +(datatype Bool) +(function TrueConst () Bool) +(let True (TrueConst)) +(function FalseConst () Bool) +(let False (FalseConst)) +(function myor (Bool Bool) Bool) +(function negate (Bool) Bool) + +; clauses are assumed in the normal form (or a (or b (or c False))) + +(union (negate False) True) +(union (negate True) False) + +; "Solving" negation equations +(rule ((= (negate p) True)) ((union p False))) +(rule ((= (negate p) False)) ((union p True))) + +; canonicalize associtivity. "append" for clauses +; terminate with false +(rewrite (myor (myor a b) c) (myor a (myor b c))) +; commutativity +(rewrite (myor a (myor b c)) (myor b (myor a c))) + +;absorption +(rewrite (myor a (myor a b)) (myor a b)) +(rewrite (myor a (myor (negate a) b)) True) + +; simplification +(rewrite (myor False a) a) +(rewrite (myor a False) a) +(rewrite (myor True a) True) +(rewrite (myor a True) True) + +; unit propagation +; This is kind of interesting actually. +; Looks a bit like equation solving + +; The following is not valid egglog but could be? +;(rewrite p True +; :when ((= True (or p False)))) + +(rule ((= True (myor p False))) ((union p True))) + +; resolution +; This counts on commutativity to bubble everything possible up to the front of the clause. +(rule ((= True (myor a as)) (= True (myor (negate a) bs))) + ((union (myor as bs) True))) + +; example predicate +(function p (i64) Bool) +(let p0 (p 0)) +(let p1 (p 1)) +(let p2 (p 2)) +;(union (or p0 (or p1 (or p2 False))) True) +;(union (or (negate p0) (or p1 (or (negate p2) False))) True) +(union (myor p1 (myor (negate p2) False)) True) +(union (myor p2 (myor (negate p0) False)) True) +(union (myor p0 (myor (negate p1) False)) True) +(union p1 False) +(union (myor (negate p0) (myor p1 (myor p2 False))) True) +(run 10) + + +(check (!= True False)) +(check (= p0 False)) +(check (= p2 False)) + +; we could turn the original axioms into _patterns_ in all possible directions. +; Which is kind of compelling +; (rule ((or (pat x))) ) +; or let a unification expansion happen and use thos + + diff --git a/tests/rw-analysis.egg b/tests/rw-analysis.egg new file mode 100644 index 0000000..154066c --- /dev/null +++ b/tests/rw-analysis.egg @@ -0,0 +1,284 @@ +;;;;;;;;;;;;;;;; +;; Abstact Domain +;;;;;;;;;;;;;;;; + +; Top means it can be an arbitrary value +(datatype Val (I i64)) +(function TopConst () Val) +(let Top (TopConst)) +(function TrueConst () Val) +(let True (TrueConst)) +(function FalseConst () Val) +(let False (FalseConst)) +(relation Bool (Val)) +(Bool True) +(Bool False) + +(function merge-val (Val Val) Val) + +(rewrite (merge-val Top x) Top) +(rewrite (merge-val x Top) Top) +(rewrite (merge-val True False) Top) +(rewrite (merge-val True (I x)) Top) +(rewrite (merge-val False True) Top) +(rewrite (merge-val False (I x)) Top) +(rewrite (merge-val (I x) (I y)) Top :when ((!= x y))) +(rewrite (merge-val x x) x) + +(function add-val (Val Val) Val) + +(rewrite (add-val Top x) Top) +(rewrite (add-val x Top) Top) +(rewrite (add-val True x) Top) +(rewrite (add-val False x) Top) +(rewrite (add-val x True) Top) +(rewrite (add-val x False) Top) +(rewrite (add-val (I x) (I y)) (I (+ x y))) + +(function eq-val (Val Val) Val) + +(rewrite (eq-val Top x) Top) +(rewrite (eq-val x Top) Top) +(rewrite (eq-val True False) False) +(rewrite (eq-val True (I x)) False) +(rewrite (eq-val False True) False) +(rewrite (eq-val False (I x)) False) +(rewrite (eq-val (I x) True) False) +(rewrite (eq-val (I x) False) False) +(rewrite (eq-val x x) True) + +(datatype VarT (V String)) +(datatype Loc (L i64)) +(datatype Exp + (Add VarT VarT) + (Eq VarT VarT) + (Var VarT) + (Const Val)) +(datatype ProgStmt + (Ass VarT Exp) + (If VarT Loc Loc) + (Goto Loc) + (Call VarT)) +(function EndConst () ProgStmt) +(let End (EndConst)) +(function Prog (Loc) ProgStmt) +(relation RProg (Loc ProgStmt)) + +(function const-prop (Loc VarT) Val :merge (merge-val old new)) + +;;;;;;;;;;;;;;;; +;; ASS Case +;;;;;;;;;;;;;;;; + +;; PROPAGATION + +; propagate x = k +(rule ( + (RProg (L li) (Ass x (Const k))) +)( + (set (const-prop (L (+ li 1)) x) k) +)) + +; propagate x = a + b (non-constant) +(rule ( + (RProg l (Ass x (Add x1 x2))) + (= v1 (const-prop l x1)) + (= v2 (const-prop l x2)) + (= l (L li)) +)( + (set (const-prop (L (+ li 1)) x) (add-val v1 v2)) +)) + +; propagate x = a == b +(rule ( + (RProg l (Ass x (Eq x1 x2))) + (= v1 (const-prop l x1)) + (= v2 (const-prop l x2)) + (= l (L li)) +)( + (set (const-prop (L (+ li 1)) x) (eq-val v1 v2)) +)) + +; propagate other vars +(rule ( + (RProg (L li) (Ass (V x) e)) + (= val (const-prop (L li) (V y))) + (!= x y) +)( + (set (const-prop (L (+ li 1)) (V y)) val) +)) + +;; TRANSFORMATION + +; generate demand for biop +(rule ( + (= (Prog l) (Ass x (Add x1 x2))) + (= v1 (const-prop l x1)) + (= v2 (const-prop l x2)) +)( + (add-val v1 v2) +)) + +(rule ( + (= (Prog l) (Ass x (Eq x1 x2))) + (= v1 (const-prop l x1)) + (= v2 (const-prop l x2)) +)( + (eq-val v1 v2) +)) + +; replace x = a + b (constant) +(rule ( + (= (Prog l) (Ass x (Add x1 x2))) + (= (I val) (add-val (const-prop l x1) + (const-prop l x2))) +)( + (RProg l (Ass x (Const (I val)))) +)) + +; replace x = a + b (non-contant) +(rule ( + (= (Prog l) (Ass x (Add x1 x2))) + (= Top (add-val (const-prop l x1) + (const-prop l x2))) +)( + (RProg l (Ass x (Add x1 x2))) +)) + +; replace x = a == b (constant) +(rule ( + (= (Prog l) (Ass x (Eq x1 x2))) + (= b (eq-val (const-prop l x1) (const-prop l x2))) + (Bool b) +)( + (RProg l (Ass x (Const b))) +)) + +; replace x = a == b (non-constant) +(rule ( + (= (Prog l) (Ass x (Eq x1 x2))) + (= Top (eq-val (const-prop l x1) (const-prop l x2))) +)( + (RProg l (Ass x (Eq x1 x2))) +)) + +; replace x = k +(rule ( + (= (Prog l) (Ass x (Const val))) +)( + (RProg l (Ass x (Const val))) +)) + +;;;;;;;;;;;;;;;; +;; CALL CASE +;;;;;;;;;;;;;;;; + +;; PROPAGATION +(rule ( + (RProg l (Call f)) + (= val (const-prop l x)) + (= l (L li)) +)( + (set (const-prop (L (+ li 1)) x) val) +)) + +;; TRANSFORMATION +(rule ( + (= (Prog l) (Call f)) +)( + (RProg l (Call f)) +)) + +;;;;;;;;;;;;;;;; +;; IF CASE +;;;;;;;;;;;;;;;; + +;; PROPAGATION +(rule ( + (RProg l (If b l1 l2)) + (= val (const-prop l x)) +)( + (set (const-prop l1 x) val) + (set (const-prop l2 x) val) +)) + +;; TRANSFORMATION + +; replace if true +(rule ( + (= (Prog l) (If b l1 l2)) + (= True (const-prop l b)) +)( + (RProg l (Goto l1)) +)) + +; replace if false +(rule ( + (= (Prog l) (If b l1 l2)) + (= False (const-prop l b)) +)( + (RProg l (Goto l2)) +)) + +; replace if Top +(rule ( + (= (Prog l) (If b l1 l2)) + (= Top (const-prop l b)) +)( + (RProg l (If b l1 l2)) +)) + +;;;;;;;;;;;;;;;; +;; GOTO CASE +;;;;;;;;;;;;;;;; + +;; PROPAGATION +(rule ( + (RProg l1 (Goto l2)) + (= val (const-prop l1 x)) +)( + (set (const-prop l2 x) val) +)) + +;; TRANSFORMATION +(rule ( + (= (Prog l1) (Goto l2)) +)( + (RProg l1 (Goto l2)) +)) + +;;;;;;;;;;;;;;;; +;; TEST +;;;;;;;;;;;;;;;; + +(union (Prog (L 0)) (Ass (V "b") (Const Top))) +(union (Prog (L 1)) (Ass (V "ten") (Const (I 10)))) +(union (Prog (L 2)) (Ass (V "one") (Const (I 1)))) +(union (Prog (L 3)) (Ass (V "zero") (Const (I 0)))) +; x := 10 +(union (Prog (L 4)) (Ass (V "x") (Const (I 10)))) +; while (...) { +(union (Prog (L 5)) (If (V "b") (L 6) (L 13))) +; if (x == 10) { +(union (Prog (L 6)) (Ass (V "cond") (Eq (V "x") (V "ten")))) +(union (Prog (L 7)) (If (V "cond") (L 8) (L 10))) +; DoSomething(); +(union (Prog (L 8)) (Call (V "DoSomething"))) +; } +(union (Prog (L 9)) (Goto (L 12))) +; else { +; DoSomething(); +(union (Prog (L 10)) (Call (V "DoSomethingElse"))) +; x := x + 1; +(union (Prog (L 11)) (Ass (V "x") (Add (V "x") (V "one")))) +;; (union (Prog (L 11)) (Call (V "DoSomethingElse"))) +; } +(union (Prog (L 12)) (Goto (L 5))) +; y := x +(union (Prog (L 13)) (Ass (V "y") (Add (V "x") (V "zero")))) +(union (Prog (L 14)) End) + +(run 20) + +(check (= (const-prop (L 14) (V "y")) (I 10))) + diff --git a/tests/schedule-demo.egg b/tests/schedule-demo.egg new file mode 100644 index 0000000..be2e8ef --- /dev/null +++ b/tests/schedule-demo.egg @@ -0,0 +1,28 @@ +; Step with alternating feet, left before right +(relation left (i64)) +(relation right (i64)) + +(left 0) +(right 0) + +(ruleset step-left) +(rule ((left x) (right x)) + ((left (+ x 1))) + :ruleset step-left) + +(ruleset step-right) +(rule ((left x) (right y) (= x (+ y 1))) + ((right x)) + :ruleset step-right) + +(run-schedule + (repeat 10 + (saturate step-right) + (saturate step-left))) + +; We took 10 steps with the left, but the right couldn't go the first round, +; so we took only 9 steps with the right. +(check (left 10)) +(check (right 9)) +(fail (check (left 11))) +(fail (check (right 10))) diff --git a/tests/semi_naive_set_function.egg b/tests/semi_naive_set_function.egg new file mode 100644 index 0000000..e9af5cb --- /dev/null +++ b/tests/semi_naive_set_function.egg @@ -0,0 +1,104 @@ +;; From issue#93. The change happened in right-hand-side of a rule may also impact output in semi-naive cases +(push) +(function f (i64) i64 :merge (max old new)) + +(set (f 0) 0) +(set (f 3) 0) + +(rule ((= f0 (f 0))) ((set (f 1) f0))) +(rule ((= f1 (f 1))) ((set (f 2) f1))) + +;; update f3 some iters later to make sure f(0) is inactive +(rule ((= f2 (f 2))) ((set (f 3) 3))) + +(push) + +;; This rule should fire and set f(0) to be 3, but because f0 is inactive, +;; it does not fire (despite that f3 is active now) +(rule ((= f0 (f 0))) ((set (f 0) (f 3)))) + +(run 100) +(print-function f 100) ;; f0 is expected to have value 3, but has 0 in reality. + +(check (= (f 0) 3)) +(check (= (f 1) 3)) +(check (= (f 2) 3)) +(check (= (f 3) 3)) + +(pop) +(push) + +;; variants of the last rule. +(rule ((= f0 (f 0)) (= x 3) (= y x)) ((set (f 0) (f y)))) + +(run 100) +(check (= (f 0) 3)) +(check (= (f 1) 3)) +(check (= (f 2) 3)) +(check (= (f 3) 3)) + +(pop) +(push) + +;; adding let binding +(rule ((= f0 (f 0))) ((let x 3) (let y x) (set (f 0) (f y)))) + +(run 100) +(check (= (f 0) 3)) +(check (= (f 1) 3)) +(check (= (f 2) 3)) +(check (= (f 3) 3)) + +(pop) +(push) + +(function g (i64) i64 :merge (max old new)) +(set (g 0) 3) + +;; bind to another function +(rule ((= f0 (f 0))) ((let x (g 0)) (let y x) (set (f 0) (f y)))) + +(run 100) +(check (= (f 0) 3)) +(check (= (f 1) 3)) +(check (= (f 2) 3)) +(check (= (f 3) 3)) + +(pop) +(pop) + +;; more complicated case, when the evaluation never finish +;; the semi_naive and naive behavior diverage a bit +(function f (i64) i64 :merge (max old new)) + +(set (f 0) 0) +(set (f 3) 0) + +(rule ((= f0 (f 0))) ((set (f 1) (+ 1 f0)))) +(rule ((= f1 (f 1))) ((set (f 2) (+ 1 f1)))) + +(push) + +(rule ((= f2 (f 2))) ((set (f 3) 1))) +(rule ((= f0 (f 0))) ((set (f 0) (f (f 3))))) + + +(run 100) +(print-function f 100) +(check (!= 0 (f 0))) +(check (!= 0 (f 1))) +(check (!= 0 (f 2))) + +(pop) + + +;; id function that will set all int values, but need strong induction. +(function g (i64) i64 :merge (max old new)) +(set (g 0) 0) +(set (g 1) 1) +(rule ((= x (g x)) (= y (g (- x 1)))) ((set (g (+ x 1)) (+ y 2)))) + +(run 100) +(print-function g 100) + +(check (= 20 (g 20))) \ No newline at end of file diff --git a/tests/set.egg b/tests/set.egg new file mode 100644 index 0000000..fd7ed37 --- /dev/null +++ b/tests/set.egg @@ -0,0 +1,40 @@ +(sort ISetBase (Set i64)) + +; Test set-of +(check (= (set-of 1 2) (set-insert (set-insert (set-empty) 1) 2))) +(check (= (set-of 1 2) (set-insert (set-insert (set-empty) 2) 1))) + +; Test set-union +(check (= (set-union (set-of 1 2) (set-of 3 4)) (set-of 1 2 3 4))) + +; Test set-length +(check (= 0 (set-length (set-empty)))) +(check (= 1 (set-length (set-of 1 1 1)))) +(check (= 2 (set-length (set-of 1 -1 1 1)))) + +; Test set-get +(check (= 1 (set-get (set-of 1 -1 2 4 1) 0))) +(check (= 2 (set-get (set-of 1 -1 2 4 1) 1))) +(check (= 4 (set-get (set-of 1 -1 2 4 1) 2))) +(check (= -1 (set-get (set-of 1 -1 2 4 1) 3))) + +; Test set-remove +(check (= (set-remove (set-of 1 2 3) 3) (set-of 1 2))) + +; Reify set +(sort ISet) +(function IS (ISetBase) ISet) + +(function ISet-get (ISet i64) i64 :unextractable) +(rule ((IS x) (> (set-length x) 0)) + ((set (ISet-get (IS x) 0) (set-get x 0)))) +(rule ((ISet-get (IS x) j) + (= i (+ j 1)) (< i (set-length x))) + ((set (ISet-get (IS x) i) (set-get x i)))) + +(let myset (IS (set-of 2 4 1 4 -1))) +(run 100) +(check (= 1 (ISet-get myset 0))) +(check (= 2 (ISet-get myset 1))) +(check (= 4 (ISet-get myset 2))) +(check (= -1 (ISet-get myset 3))) diff --git a/tests/stratified.egg b/tests/stratified.egg new file mode 100644 index 0000000..ca48817 --- /dev/null +++ b/tests/stratified.egg @@ -0,0 +1,28 @@ +(relation path (i64 i64)) +(relation edge (i64 i64)) + +(rule ((edge x y)) + ((path x y))) + +(edge 1 2) +(edge 2 3) +(edge 3 4) +(check (edge 1 2)) +(run 3) +(check (path 1 2)) + +(ruleset path-rules) + +(rule ((path x y) (edge y z)) + ((path x z)) + :ruleset path-rules) + +(edge 3 8) +(run path-rules 1) +(check (path 1 3)) + + + +; Should fail +; (check (path 1 4)) +; (check (path 3 8)) diff --git a/tests/stresstest_large_expr.egg b/tests/stresstest_large_expr.egg new file mode 100644 index 0000000..63ddaa4 --- /dev/null +++ b/tests/stresstest_large_expr.egg @@ -0,0 +1,440 @@ +;; Old version of python array optimization that does not include CSE with let statements +;; serves as a benchmark for adding large expressions to egglog +(ruleset array_api_ruleset) +(sort Int) +(function cast_Callable__Int__Int___Int___lambda_i_____i_ (Int Int) Int) +(rewrite (cast_Callable__Int__Int___Int___lambda_i_____i_ __var__i __var___) __var__i :ruleset array_api_ruleset) +(sort TupleInt) +(function TupleInt_single (Int) TupleInt) +(sort UnstableFn_Int_Int (UnstableFn (Int) Int)) +(function TupleInt___init__ (Int UnstableFn_Int_Int) TupleInt) +(function Int___init__ (i64) Int) +(rewrite (TupleInt_single __var__i) (TupleInt___init__ (Int___init__ 1) (unstable-fn "cast_Callable__Int__Int___Int___lambda_i_____i_" __var__i)) :ruleset array_api_ruleset) +(function cast_Callable__Int___Int___lambda_i__i_ (Int) Int) +(rewrite (cast_Callable__Int___Int___lambda_i__i_ __var__i) __var__i :ruleset array_api_ruleset) +(function TupleInt_range (Int) TupleInt) +(rewrite (TupleInt_range __var__stop) (TupleInt___init__ __var__stop (unstable-fn "cast_Callable__Int___Int___lambda_i__i_")) :ruleset array_api_ruleset) +(sort Vec_Int (Vec Int)) +(function TupleInt_from_vec (Vec_Int) TupleInt) +(function index_vec_int (Vec_Int Int) Int) +(rewrite (TupleInt_from_vec __var__vec) (TupleInt___init__ (Int___init__ (vec-length __var__vec)) (unstable-fn "index_vec_int" __var__vec)) :ruleset array_api_ruleset) +(function cast_Callable__TupleInt__TupleInt__Int___Int___lambda_other__self__i__Int_if__i_<_self_length____self_i___other_i_-_self_length_____ (TupleInt TupleInt Int) Int) +(sort Boolean) +(function Int_if_ (Boolean Int Int) Int) +(function Int___lt__ (Int Int) Boolean) +(function TupleInt_length (TupleInt) Int) +(function TupleInt___getitem__ (TupleInt Int) Int) +(function Int___sub__ (Int Int) Int) +(rewrite (cast_Callable__TupleInt__TupleInt__Int___Int___lambda_other__self__i__Int_if__i_<_self_length____self_i___other_i_-_self_length_____ __var__other __var__self __var__i) (Int_if_ (Int___lt__ __var__i (TupleInt_length __var__self)) (TupleInt___getitem__ __var__self __var__i) (TupleInt___getitem__ __var__other (Int___sub__ __var__i (TupleInt_length __var__self)))) :ruleset array_api_ruleset) +(function TupleInt___add__ (TupleInt TupleInt) TupleInt) +(function Int___add__ (Int Int) Int) +(rewrite (TupleInt___add__ __var__self __var__other) (TupleInt___init__ (Int___add__ (TupleInt_length __var__self) (TupleInt_length __var__other)) (unstable-fn "cast_Callable__TupleInt__TupleInt__Int___Int___lambda_other__self__i__Int_if__i_<_self_length____self_i___other_i_-_self_length_____" __var__other __var__self)) :ruleset array_api_ruleset) +(function cast_Callable__Int__Boolean__Int___Boolean___lambda_i__acc__j__acc_|__i_==_j__ (Int Boolean Int) Boolean) +(function Boolean___or__ (Boolean Boolean) Boolean) +(function Int___eq__ (Int Int) Boolean) +(rewrite (cast_Callable__Int__Boolean__Int___Boolean___lambda_i__acc__j__acc_|__i_==_j__ __var__i __var__acc __var__j) (Boolean___or__ __var__acc (Int___eq__ __var__i __var__j)) :ruleset array_api_ruleset) +(function TupleInt_contains (TupleInt Int) Boolean) +(sort UnstableFn_Boolean_Boolean_Int (UnstableFn (Boolean Int) Boolean)) +(function TupleInt_fold_boolean (TupleInt Boolean UnstableFn_Boolean_Boolean_Int) Boolean) +(function FALSE () Boolean) +(rewrite (TupleInt_contains __var__self __var__i) (TupleInt_fold_boolean __var__self (FALSE) (unstable-fn "cast_Callable__Int__Boolean__Int___Boolean___lambda_i__acc__j__acc_|__i_==_j__" __var__i)) :ruleset array_api_ruleset) +(sort NDArray) +(function NDArray_size (NDArray) Int) +(sort UnstableFn_Int_Int_Int (UnstableFn (Int Int) Int)) +(function TupleInt_fold (TupleInt Int UnstableFn_Int_Int_Int) Int) +(function NDArray_shape (NDArray) TupleInt) +(function Int___mul__ (Int Int) Int) +(rewrite (NDArray_size __var__x) (TupleInt_fold (NDArray_shape __var__x) (Int___init__ 1) (unstable-fn "Int___mul__")) :ruleset array_api_ruleset) +(function unique_values (NDArray) NDArray) +(sort TupleValue) +(function NDArray_vector (TupleValue) NDArray) +(sort Value) +(function possible_values (Value) TupleValue) +(function NDArray_index (NDArray TupleInt) Value) +(function ALL_INDICES () TupleInt) +(rewrite (unique_values __var__a) (NDArray_vector (possible_values (NDArray_index __var__a (ALL_INDICES)))) :ruleset array_api_ruleset) +(function Value_isfinite (Value) Boolean) +(function Value_int (Int) Value) +(function TRUE () Boolean) +(rewrite (Value_isfinite (Value_int __var__i)) (TRUE) :ruleset array_api_ruleset) +(function Value_bool (Boolean) Value) +(rewrite (Value_isfinite (Value_bool __var__b)) (TRUE) :ruleset array_api_ruleset) +(sort Float) +(function Value_float (Float) Value) +(function Float___init__ (f64) Float :cost 3) +(rewrite (Value_isfinite (Value_float (Float___init__ __var__f))) (TRUE) :when ((!= __var__f NaN)) :ruleset array_api_ruleset) +(function isfinite (NDArray) NDArray) +(sort OptionalIntOrTuple) +(function sum (NDArray OptionalIntOrTuple) NDArray) +(function OptionalIntOrTuple_none () OptionalIntOrTuple) +(function NDArray_scalar (Value) NDArray) +(rewrite (isfinite (sum __var__arr (OptionalIntOrTuple_none))) (NDArray_scalar (Value_bool (Value_isfinite (NDArray_index __var__arr (ALL_INDICES))))) :ruleset array_api_ruleset) +(function assume_value_one_of (NDArray TupleValue) NDArray) +(rewrite (NDArray_shape (assume_value_one_of __var__x __var__vs)) (NDArray_shape __var__x) :ruleset array_api_ruleset) +(sort DType) +(function NDArray_dtype (NDArray) DType) +(rewrite (NDArray_dtype (assume_value_one_of __var__x __var__vs)) (NDArray_dtype __var__x) :ruleset array_api_ruleset) +(rule ((= __var__v (NDArray_index (assume_value_one_of __var__x __var__vs) __var__idx))) + ((union __var__v (NDArray_index __var__x __var__idx)) + (union (possible_values __var__v) __var__vs)) + :ruleset array_api_ruleset ) +(function assume_isfinite (NDArray) NDArray) +(rewrite (NDArray_shape (assume_isfinite __var__x)) (NDArray_shape __var__x) :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (assume_isfinite __var__x)) (NDArray_dtype __var__x) :ruleset array_api_ruleset) +(rewrite (NDArray_index (assume_isfinite __var__x) __var__ti) (NDArray_index __var__x __var__ti) :ruleset array_api_ruleset) +(rewrite (Value_isfinite (NDArray_index (assume_isfinite __var__x) __var__ti)) (TRUE) :ruleset array_api_ruleset) +(function assume_shape (NDArray TupleInt) NDArray) +(rewrite (NDArray_shape (assume_shape __var__x __var__shape)) __var__shape :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (assume_shape __var__x __var__shape)) (NDArray_dtype __var__x) :ruleset array_api_ruleset) +(rewrite (NDArray_index (assume_shape __var__x __var__shape) __var__idx) (NDArray_index __var__x __var__idx) :ruleset array_api_ruleset) +(function assume_dtype (NDArray DType) NDArray) +(rewrite (NDArray_dtype (assume_dtype __var__x __var__dtype)) __var__dtype :ruleset array_api_ruleset) +(rewrite (NDArray_shape (assume_dtype __var__x __var__dtype)) (NDArray_shape __var__x) :ruleset array_api_ruleset) +(rewrite (NDArray_index (assume_dtype __var__x __var__dtype) __var__idx) (NDArray_index __var__x __var__idx) :ruleset array_api_ruleset) +(sort IndexKey) +(function NDArray___getitem__ (NDArray IndexKey) NDArray) +(function IndexKey_int (Int) IndexKey) +(rewrite (NDArray___getitem__ __var__x (IndexKey_int __var__i)) (NDArray_scalar (NDArray_index __var__x (TupleInt_single __var__i))) :ruleset array_api_ruleset) +(sort OptionalBool) +(function reshape (NDArray TupleInt OptionalBool) NDArray) +(rule ((= __a (reshape __var__x __var__shape __var__copy))) + ((NDArray_shape __var__x) + (TupleInt_length (NDArray_shape __var__x))) + :ruleset array_api_ruleset ) +(rule ((reshape __var__x __var__shape __var__copy)) + ((TupleInt_length __var__shape) + (TupleInt___getitem__ __var__shape (Int___init__ 0))) + :ruleset array_api_ruleset ) +(rewrite (reshape __var__x __var__shape __var__copy) __var__x :when ((= (TupleInt_length (NDArray_shape __var__x)) (Int___init__ 1)) (= (TupleInt_length __var__shape) (Int___init__ 1)) (= (TupleInt___getitem__ __var__shape (Int___init__ 0)) (Int___init__ -1))) :ruleset array_api_ruleset) +(function TupleValue_length (TupleValue) Int) +(rewrite (NDArray_shape (NDArray_vector __var__vs)) (TupleInt_single (TupleValue_length __var__vs)) :ruleset array_api_ruleset) +(function Value_dtype (Value) DType) +(function TupleValue___getitem__ (TupleValue Int) Value) +(rewrite (NDArray_dtype (NDArray_vector __var__vs)) (Value_dtype (TupleValue___getitem__ __var__vs (Int___init__ 0))) :ruleset array_api_ruleset) +(rewrite (NDArray_index (NDArray_vector __var__vs) __var__ti) (TupleValue___getitem__ __var__vs (TupleInt___getitem__ __var__ti (Int___init__ 0))) :ruleset array_api_ruleset) +(function TupleInt_EMPTY () TupleInt) +(rewrite (NDArray_shape (NDArray_scalar __var__v)) (TupleInt_EMPTY) :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (NDArray_scalar __var__v)) (Value_dtype __var__v) :ruleset array_api_ruleset) +(rewrite (NDArray_index (NDArray_scalar __var__v) (TupleInt_EMPTY)) __var__v :ruleset array_api_ruleset) +(function any (NDArray) NDArray) +(function TupleValue_includes (TupleValue Value) Boolean) +(function Value_to_truthy_value (Value) Value) +(rewrite (any __var__x) (NDArray_scalar (Value_bool (TupleValue_includes (possible_values (Value_to_truthy_value (NDArray_index __var__x (ALL_INDICES)))) (Value_bool (TRUE))))) :ruleset array_api_ruleset) +(function NDArray___lt__ (NDArray NDArray) NDArray) +(function Value___lt__ (Value Value) Value) +(function broadcast_index (TupleInt TupleInt TupleInt) TupleInt) +(function broadcast_shapes (TupleInt TupleInt) TupleInt) +(rewrite (NDArray_index (NDArray___lt__ __var__x __var__y) __var__idx) (Value___lt__ (NDArray_index __var__x (broadcast_index (NDArray_shape __var__x) (broadcast_shapes (NDArray_shape __var__x) (NDArray_shape __var__y)) __var__idx)) (NDArray_index __var__y (broadcast_index (NDArray_shape __var__y) (broadcast_shapes (NDArray_shape __var__x) (NDArray_shape __var__y)) __var__idx))) :ruleset array_api_ruleset) +(function NDArray___truediv__ (NDArray NDArray) NDArray) +(function Value___truediv__ (Value Value) Value) +(rewrite (NDArray_index (NDArray___truediv__ __var__x __var__y) __var__idx) (Value___truediv__ (NDArray_index __var__x (broadcast_index (NDArray_shape __var__x) (broadcast_shapes (NDArray_shape __var__x) (NDArray_shape __var__y)) __var__idx)) (NDArray_index __var__y (broadcast_index (NDArray_shape __var__y) (broadcast_shapes (NDArray_shape __var__x) (NDArray_shape __var__y)) __var__idx))) :ruleset array_api_ruleset) +(rewrite (NDArray_index (NDArray_scalar __var__v) __var__idx) __var__v :ruleset array_api_ruleset) +(function astype (NDArray DType) NDArray) +(function Value_astype (Value DType) Value) +(rewrite (NDArray_index (astype __var__x __var__dtype) __var__idx) (Value_astype (NDArray_index __var__x __var__idx) __var__dtype) :ruleset array_api_ruleset) +(relation greater_zero (Value)) +(sort TupleNDArray) +(function TupleNDArray___getitem__ (TupleNDArray Int) NDArray) +(function unique_counts (NDArray) TupleNDArray) +(rule ((= __var__v (NDArray_index (TupleNDArray___getitem__ (unique_counts __var__x) (Int___init__ 1)) __var__idx))) + ((greater_zero __var__v)) + :ruleset array_api_ruleset ) +(rule ((greater_zero __var__v) + (= __var__v1 (Value_astype __var__v __var__dtype))) + ((greater_zero __var__v1)) + :ruleset array_api_ruleset ) +(rule ((= __var__v (Value_float (Float___init__ __var__f))) + (> __var__f 0.0)) + ((greater_zero __var__v)) + :ruleset array_api_ruleset ) +(rule ((= __var__v (Value_int (Int___init__ __var__i))) + (> __var__i 0)) + ((greater_zero __var__v)) + :ruleset array_api_ruleset ) +(rule ((greater_zero __var__v) + (greater_zero __var__v1) + (= __var__v2 (Value___truediv__ __var__v __var__v1))) + ((greater_zero __var__v2)) + :ruleset array_api_ruleset ) +(rule ((greater_zero __var__v) + (= __var__v1 (Value___lt__ __var__v (Value_int (Int___init__ 0))))) + ((union __var__v1 (Value_bool (FALSE)))) + :ruleset array_api_ruleset ) +(function TupleValue___init__ (Value) TupleValue) +(rewrite (possible_values (Value_bool __var__b)) (TupleValue___init__ (Value_bool __var__b)) :ruleset array_api_ruleset) +(rule ((= __var__v1 (Value_astype __var__v __var__dtype)) + (greater_zero __var__v)) + ((greater_zero __var__v1)) + :ruleset array_api_ruleset ) +(function TupleNDArray_length (TupleNDArray) Int) +(function svd (NDArray Boolean) TupleNDArray) +(rewrite (TupleNDArray_length (svd __var__x __var__full_matrices)) (Int___init__ 3) :ruleset array_api_ruleset) +(function unique_inverse (NDArray) TupleNDArray) +(rewrite (TupleNDArray_length (unique_inverse __var__x)) (Int___init__ 2) :ruleset array_api_ruleset) +(rewrite (TupleNDArray___getitem__ (unique_inverse __var__x) (Int___init__ 0)) (unique_values __var__x) :ruleset array_api_ruleset) +(function ndarray-abs (NDArray) NDArray) +(function Float_abs (Float) Float) +(rewrite (ndarray-abs (NDArray_scalar (Value_float __var__f))) (NDArray_scalar (Value_float (Float_abs __var__f))) :ruleset array_api_ruleset) +(rewrite (TupleNDArray_length (unique_counts __var__x)) (Int___init__ 2) :ruleset array_api_ruleset) +(rewrite (sum (TupleNDArray___getitem__ (unique_counts __var__x) (Int___init__ 1)) (OptionalIntOrTuple_none)) (NDArray_scalar (Value_int (NDArray_size __var__x))) :ruleset array_api_ruleset) +(rewrite (sum (astype (TupleNDArray___getitem__ (unique_counts __var__x) (Int___init__ 1)) __var__dtype) (OptionalIntOrTuple_none)) (astype (NDArray_scalar (Value_int (NDArray_size __var__x))) __var__dtype) :ruleset array_api_ruleset) +(rewrite (NDArray_dtype (astype __var__x __var__dtype)) __var__dtype :ruleset array_api_ruleset) +(function DType_float64 () DType) +(rewrite (astype (NDArray_scalar (Value_int (Int___init__ __var__i))) (DType_float64)) (NDArray_scalar (Value_float (Float___init__ (to-f64 __var__i)))) :ruleset array_api_ruleset) +(sort OptionalInt) +(function concat (TupleNDArray OptionalInt) NDArray) +(function TupleNDArray___init__ (NDArray) TupleNDArray) +(function OptionalInt_none () OptionalInt) +(rewrite (concat (TupleNDArray___init__ __var__x) (OptionalInt_none)) __var__x :ruleset array_api_ruleset) +(rewrite (unique_values (unique_values __var__x)) (unique_values __var__x) :ruleset array_api_ruleset) +(rewrite (sum (NDArray___truediv__ __var__x (NDArray_scalar __var__v)) (OptionalIntOrTuple_none)) (NDArray___truediv__ (sum __var__x (OptionalIntOrTuple_none)) (NDArray_scalar __var__v)) :ruleset array_api_ruleset) +(function NDArray_ndim (NDArray) Int) +(sort OptionalDType) +(sort OptionalDevice) +(function asarray (NDArray OptionalDType OptionalBool OptionalDevice) NDArray) +(function OptionalDevice_none () OptionalDevice) +(rewrite (NDArray_ndim (asarray __var__a __var__d __var__ob (OptionalDevice_none))) (NDArray_ndim __var__a) :ruleset array_api_ruleset) +(function OptionalDType_none () OptionalDType) +(function OptionalBool_none () OptionalBool) +(rewrite (asarray __var__a (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) __var__a :ruleset array_api_ruleset) +(function TupleNDArray___add__ (TupleNDArray TupleNDArray) TupleNDArray) +(function TupleNDArray_EMPTY () TupleNDArray) +(rewrite (TupleNDArray___add__ __var__ti (TupleNDArray_EMPTY)) __var__ti :ruleset array_api_ruleset) +(rewrite (TupleNDArray_length (TupleNDArray___init__ __var__n)) (Int___init__ 1) :ruleset array_api_ruleset) +(rewrite (TupleNDArray_length (TupleNDArray___add__ __var__ti __var__ti2)) (Int___add__ (TupleNDArray_length __var__ti) (TupleNDArray_length __var__ti2)) :ruleset array_api_ruleset) +(rewrite (NDArray_ndim __var__x) (TupleInt_length (NDArray_shape __var__x)) :ruleset array_api_ruleset) +(function NDArray_to_value (NDArray) Value) +(rewrite (NDArray_to_value __var__x) (NDArray_index __var__x (TupleInt_EMPTY)) :ruleset array_api_ruleset) +(rewrite (NDArray___truediv__ (NDArray_scalar (Value_float __var__f)) (NDArray_scalar (Value_float __var__f))) (NDArray_scalar (Value_float (Float___init__ 1.0))) :ruleset array_api_ruleset) +(function NDArray___sub__ (NDArray NDArray) NDArray) +(rewrite (NDArray___sub__ (NDArray_scalar (Value_float __var__f)) (NDArray_scalar (Value_float __var__f))) (NDArray_scalar (Value_float (Float___init__ 0.0))) :ruleset array_api_ruleset) +(function NDArray___gt__ (NDArray NDArray) NDArray) +(rewrite (NDArray___gt__ (NDArray_scalar (Value_float (Float___init__ __var__fi1))) (NDArray_scalar (Value_float (Float___init__ __var__fi2)))) (NDArray_scalar (Value_bool (TRUE))) :when ((> __var__fi1 __var__fi2)) :ruleset array_api_ruleset) +(rewrite (NDArray___gt__ (NDArray_scalar (Value_float (Float___init__ __var__fi1))) (NDArray_scalar (Value_float (Float___init__ __var__fi2)))) (NDArray_scalar (Value_bool (FALSE))) :when ((<= __var__fi1 __var__fi2)) :ruleset array_api_ruleset) +(function NDArray_T (NDArray) NDArray) +(rewrite (NDArray_T (NDArray_T __var__x)) __var__x :ruleset array_api_ruleset) +(function TupleValue___add__ (TupleValue TupleValue) TupleValue) +(function TupleValue_EMPTY () TupleValue) +(rewrite (TupleValue___add__ __var__ti (TupleValue_EMPTY)) __var__ti :ruleset array_api_ruleset) +(rewrite (TupleValue_length (TupleValue_EMPTY)) (Int___init__ 0) :ruleset array_api_ruleset) +(rewrite (TupleValue_length (TupleValue___init__ __var__v)) (Int___init__ 1) :ruleset array_api_ruleset) +(rewrite (TupleValue_length (TupleValue___add__ __var__ti __var__ti2)) (Int___add__ (TupleValue_length __var__ti) (TupleValue_length __var__ti2)) :ruleset array_api_ruleset) +(rewrite (TupleValue___getitem__ (TupleValue___init__ __var__v) (Int___init__ 0)) __var__v :ruleset array_api_ruleset) +(rewrite (TupleValue___getitem__ (TupleValue___add__ (TupleValue___init__ __var__v) __var__ti) (Int___init__ 0)) __var__v :ruleset array_api_ruleset) +(rule ((= __var__v (TupleValue___getitem__ (TupleValue___add__ (TupleValue___init__ __var__v2) __var__ti) (Int___init__ __var__k))) + (> __var__k 0)) + ((union __var__v (TupleValue___getitem__ __var__ti (Int___init__ (- __var__k 1))))) + :ruleset array_api_ruleset ) +(rewrite (TupleValue_includes (TupleValue_EMPTY) __var__v) (FALSE) :ruleset array_api_ruleset) +(rewrite (TupleValue_includes (TupleValue___init__ __var__v) __var__v) (TRUE) :ruleset array_api_ruleset) +(rewrite (TupleValue_includes (TupleValue___init__ __var__v) __var__v2) (FALSE) :when ((!= __var__v __var__v2)) :ruleset array_api_ruleset) +(rewrite (TupleValue_includes (TupleValue___add__ __var__ti __var__ti2) __var__v) (Boolean___or__ (TupleValue_includes __var__ti __var__v) (TupleValue_includes __var__ti2 __var__v)) :ruleset array_api_ruleset) +(function DType_int64 () DType) +(rewrite (Value_dtype (Value_int __var__i)) (DType_int64) :ruleset array_api_ruleset) +(rewrite (Value_dtype (Value_float __var__f)) (DType_float64) :ruleset array_api_ruleset) +(function DType_bool () DType) +(rewrite (Value_dtype (Value_bool __var__b)) (DType_bool) :ruleset array_api_ruleset) +(function Value_to_bool (Value) Boolean) +(rewrite (Value_to_bool (Value_bool __var__b)) __var__b :ruleset array_api_ruleset) +(function Value_to_int (Value) Int) +(rewrite (Value_to_int (Value_int __var__i)) __var__i :ruleset array_api_ruleset) +(rewrite (Value_to_truthy_value (Value_bool __var__b)) (Value_bool __var__b) :ruleset array_api_ruleset) +(sort IsDtypeKind) +(function isdtype (DType IsDtypeKind) Boolean) +(function DType_float32 () DType) +(function IsDtypeKind_string (String) IsDtypeKind) +(rewrite (isdtype (DType_float32) (IsDtypeKind_string "integral")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float64) (IsDtypeKind_string "integral")) (FALSE) :ruleset array_api_ruleset) +(function DType_object () DType) +(rewrite (isdtype (DType_object) (IsDtypeKind_string "integral")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int64) (IsDtypeKind_string "integral")) (TRUE) :ruleset array_api_ruleset) +(function DType_int32 () DType) +(rewrite (isdtype (DType_int32) (IsDtypeKind_string "integral")) (TRUE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float32) (IsDtypeKind_string "real floating")) (TRUE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float64) (IsDtypeKind_string "real floating")) (TRUE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_object) (IsDtypeKind_string "real floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int64) (IsDtypeKind_string "real floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int32) (IsDtypeKind_string "real floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float32) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_float64) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_object) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int64) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(rewrite (isdtype (DType_int32) (IsDtypeKind_string "complex floating")) (FALSE) :ruleset array_api_ruleset) +(function IsDtypeKind_NULL () IsDtypeKind) +(rewrite (isdtype __var__d (IsDtypeKind_NULL)) (FALSE) :ruleset array_api_ruleset) +(function IsDtypeKind_dtype (DType) IsDtypeKind) +(rewrite (isdtype __var__d (IsDtypeKind_dtype __var__d)) (TRUE) :ruleset array_api_ruleset) +(function IsDtypeKind___or__ (IsDtypeKind IsDtypeKind) IsDtypeKind :cost 10) +(rewrite (isdtype __var__d (IsDtypeKind___or__ __var__k1 __var__k2)) (Boolean___or__ (isdtype __var__d __var__k1) (isdtype __var__d __var__k2)) :ruleset array_api_ruleset) +(rewrite (IsDtypeKind___or__ __var__k1 (IsDtypeKind_NULL)) __var__k1 :ruleset array_api_ruleset) +(function DType___eq__ (DType DType) Boolean) +(rewrite (DType___eq__ (DType_float64) (DType_float64)) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float64) (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float64) (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float64) (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float64) (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_float64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_float32)) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_float32) (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_float64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_int32)) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int32) (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_float64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_int64)) (TRUE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_int64) (DType_object)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_float64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_float32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_int32)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_int64)) (FALSE) :ruleset array_api_ruleset) +(rewrite (DType___eq__ (DType_object) (DType_object)) (TRUE) :ruleset array_api_ruleset) +(function cast_Callable__UnstableFn_Int__Int___Int___Int___lambda_idx_fn__i__idx_fn_i_+_Int_1___ (UnstableFn_Int_Int Int) Int) +(rewrite (cast_Callable__UnstableFn_Int__Int___Int___Int___lambda_idx_fn__i__idx_fn_i_+_Int_1___ __var__idx_fn __var__i) (unstable-app __var__idx_fn (Int___add__ __var__i (Int___init__ 1))) :ruleset array_api_ruleset) +(rewrite (index_vec_int __var__vs (Int___init__ __var__k)) (vec-get __var__vs __var__k) :ruleset array_api_ruleset) +(rewrite (TupleInt_length (TupleInt___init__ __var__i __var__idx_fn)) __var__i :ruleset array_api_ruleset) +(rewrite (TupleInt___getitem__ (TupleInt___init__ __var__i __var__idx_fn) __var__i2) (unstable-app __var__idx_fn __var__i2) :ruleset array_api_ruleset) +(rewrite (TupleInt_fold (TupleInt___init__ (Int___init__ 0) __var__idx_fn) __var__i __var__f) __var__i :ruleset array_api_ruleset) +(rewrite (TupleInt_fold (TupleInt___init__ (Int___init__ __var__k) __var__idx_fn) __var__i __var__f) (unstable-app __var__f (TupleInt_fold (TupleInt___init__ (Int___init__ (- __var__k 1)) (unstable-fn "cast_Callable__UnstableFn_Int__Int___Int___Int___lambda_idx_fn__i__idx_fn_i_+_Int_1___" __var__idx_fn)) __var__i __var__f) (unstable-app __var__idx_fn (Int___init__ 0))) :when ((!= __var__k 0)) :ruleset array_api_ruleset) +(rewrite (TupleInt_fold_boolean (TupleInt___init__ (Int___init__ 0) __var__idx_fn) __var__b __var__bool_f) __var__b :ruleset array_api_ruleset) +(rewrite (TupleInt_fold_boolean (TupleInt___init__ (Int___init__ __var__k) __var__idx_fn) __var__b __var__bool_f) (unstable-app __var__bool_f (TupleInt_fold_boolean (TupleInt___init__ (Int___init__ (- __var__k 1)) (unstable-fn "cast_Callable__UnstableFn_Int__Int___Int___Int___lambda_idx_fn__i__idx_fn_i_+_Int_1___" __var__idx_fn)) __var__b __var__bool_f) (unstable-app __var__idx_fn (Int___init__ 0))) :when ((!= __var__k 0)) :ruleset array_api_ruleset) +(function bottom_indexing (Int) Int) +(rewrite (TupleInt_EMPTY) (TupleInt___init__ (Int___init__ 0) (unstable-fn "bottom_indexing")) :ruleset array_api_ruleset) +(rewrite (Float_abs (Float___init__ __var__f)) (Float___init__ __var__f) :when ((>= __var__f 0.0)) :ruleset array_api_ruleset) +(rewrite (Float_abs (Float___init__ __var__f)) (Float___init__ (neg __var__f)) :when ((< __var__f 0.0)) :ruleset array_api_ruleset) +(function Float_rational (Rational) Float :cost 2) +(rewrite (Float___init__ __var__f) (Float_rational (rational (to-i64 __var__f) 1)) :when ((= (to-f64 (to-i64 __var__f)) __var__f)) :ruleset array_api_ruleset) +(function Float_from_int (Int) Float) +(rewrite (Float_from_int (Int___init__ __var__i)) (Float_rational (rational __var__i 1)) :ruleset array_api_ruleset) +(function Float___add__ (Float Float) Float) +(rewrite (Float___add__ (Float___init__ __var__f) (Float___init__ __var__f2)) (Float___init__ (+ __var__f __var__f2)) :ruleset array_api_ruleset) +(function Float___sub__ (Float Float) Float) +(rewrite (Float___sub__ (Float___init__ __var__f) (Float___init__ __var__f2)) (Float___init__ (- __var__f __var__f2)) :ruleset array_api_ruleset) +(function Float___mul__ (Float Float) Float) +(rewrite (Float___mul__ (Float___init__ __var__f) (Float___init__ __var__f2)) (Float___init__ (* __var__f __var__f2)) :ruleset array_api_ruleset) +(function Float___truediv__ (Float Float) Float) +(rewrite (Float___truediv__ (Float_rational __var__r) (Float_rational __var__r1)) (Float_rational (/ __var__r __var__r1)) :ruleset array_api_ruleset) +(rewrite (Float___add__ (Float_rational __var__r) (Float_rational __var__r1)) (Float_rational (+ __var__r __var__r1)) :ruleset array_api_ruleset) +(rewrite (Float___sub__ (Float_rational __var__r) (Float_rational __var__r1)) (Float_rational (- __var__r __var__r1)) :ruleset array_api_ruleset) +(rewrite (Float___mul__ (Float_rational __var__r) (Float_rational __var__r1)) (Float_rational (* __var__r __var__r1)) :ruleset array_api_ruleset) +(rewrite (Int___eq__ (Int___init__ __var__i) (Int___init__ __var__i)) (TRUE) :ruleset array_api_ruleset) +(rule ((= __var__r (Int___eq__ (Int___init__ __var__i) (Int___init__ __var__j))) + (!= __var__i __var__j)) + ((union __var__r (FALSE))) + :ruleset array_api_ruleset ) +(function Int___ge__ (Int Int) Boolean) +(rewrite (Int___ge__ (Int___init__ __var__i) (Int___init__ __var__i)) (TRUE) :ruleset array_api_ruleset) +(rule ((= __var__r (Int___ge__ (Int___init__ __var__i) (Int___init__ __var__j))) + (> __var__i __var__j)) + ((union __var__r (TRUE))) + :ruleset array_api_ruleset ) +(rule ((= __var__r (Int___ge__ (Int___init__ __var__i) (Int___init__ __var__j))) + (< __var__i __var__j)) + ((union __var__r (FALSE))) + :ruleset array_api_ruleset ) +(rewrite (Int___lt__ (Int___init__ __var__i) (Int___init__ __var__i)) (FALSE) :ruleset array_api_ruleset) +(rule ((= __var__r (Int___lt__ (Int___init__ __var__i) (Int___init__ __var__j))) + (< __var__i __var__j)) + ((union __var__r (TRUE))) + :ruleset array_api_ruleset ) +(rule ((= __var__r (Int___lt__ (Int___init__ __var__i) (Int___init__ __var__j))) + (> __var__i __var__j)) + ((union __var__r (FALSE))) + :ruleset array_api_ruleset ) +(function Int___gt__ (Int Int) Boolean) +(rewrite (Int___gt__ (Int___init__ __var__i) (Int___init__ __var__i)) (FALSE) :ruleset array_api_ruleset) +(rule ((= __var__r (Int___gt__ (Int___init__ __var__i) (Int___init__ __var__j))) + (> __var__i __var__j)) + ((union __var__r (TRUE))) + :ruleset array_api_ruleset ) +(rule ((= __var__r (Int___gt__ (Int___init__ __var__i) (Int___init__ __var__j))) + (< __var__i __var__j)) + ((union __var__r (FALSE))) + :ruleset array_api_ruleset ) +(function Int_i64 (Int) i64) +(rule ((= __var__o (Int___init__ __var__j))) + ((set (Int_i64 __var__o) __var__j)) + :ruleset array_api_ruleset ) +(rewrite (Int___add__ (Int___init__ __var__i) (Int___init__ __var__j)) (Int___init__ (+ __var__i __var__j)) :ruleset array_api_ruleset) +(rewrite (Int___sub__ (Int___init__ __var__i) (Int___init__ __var__j)) (Int___init__ (- __var__i __var__j)) :ruleset array_api_ruleset) +(rewrite (Int___mul__ (Int___init__ __var__i) (Int___init__ __var__j)) (Int___init__ (* __var__i __var__j)) :ruleset array_api_ruleset) +(function Int___truediv__ (Int Int) Int) +(rewrite (Int___truediv__ (Int___init__ __var__i) (Int___init__ __var__j)) (Int___init__ (/ __var__i __var__j)) :ruleset array_api_ruleset) +(function Int___mod__ (Int Int) Int) +(rewrite (Int___mod__ (Int___init__ __var__i) (Int___init__ __var__j)) (Int___init__ (% __var__i __var__j)) :ruleset array_api_ruleset) +(function Int___and__ (Int Int) Int) +(rewrite (Int___and__ (Int___init__ __var__i) (Int___init__ __var__j)) (Int___init__ (& __var__i __var__j)) :ruleset array_api_ruleset) +(function Int___or__ (Int Int) Int) +(rewrite (Int___or__ (Int___init__ __var__i) (Int___init__ __var__j)) (Int___init__ (| __var__i __var__j)) :ruleset array_api_ruleset) +(function Int___xor__ (Int Int) Int) +(rewrite (Int___xor__ (Int___init__ __var__i) (Int___init__ __var__j)) (Int___init__ (^ __var__i __var__j)) :ruleset array_api_ruleset) +(function Int___lshift__ (Int Int) Int) +(rewrite (Int___lshift__ (Int___init__ __var__i) (Int___init__ __var__j)) (Int___init__ (<< __var__i __var__j)) :ruleset array_api_ruleset) +(function Int___rshift__ (Int Int) Int) +(rewrite (Int___rshift__ (Int___init__ __var__i) (Int___init__ __var__j)) (Int___init__ (>> __var__i __var__j)) :ruleset array_api_ruleset) +(function Int___invert__ (Int) Int) +(rewrite (Int___invert__ (Int___init__ __var__i)) (Int___init__ (not-i64 __var__i)) :ruleset array_api_ruleset) +(rewrite (Int_if_ (TRUE) __var__o __var__b) __var__o :ruleset array_api_ruleset) +(rewrite (Int_if_ (FALSE) __var__o __var__b) __var__b :ruleset array_api_ruleset) +(function Boolean_bool (Boolean) bool) +(rule ((= __var__x (TRUE))) + ((set (Boolean_bool __var__x) true)) + :ruleset array_api_ruleset ) +(rule ((= __var__x (FALSE))) + ((set (Boolean_bool __var__x) false)) + :ruleset array_api_ruleset ) +(rewrite (Boolean___or__ (TRUE) __var__x) (TRUE) :ruleset array_api_ruleset) +(rewrite (Boolean___or__ (FALSE) __var__x) __var__x :ruleset array_api_ruleset) +(function Boolean___and__ (Boolean Boolean) Boolean) +(rewrite (Boolean___and__ (TRUE) __var__x) __var__x :ruleset array_api_ruleset) +(rewrite (Boolean___and__ (FALSE) __var__x) (FALSE) :ruleset array_api_ruleset) +(function Boolean_if_int (Boolean Int Int) Int) +(rewrite (Boolean_if_int (TRUE) __var__i __var__j) __var__i :ruleset array_api_ruleset) +(rewrite (Boolean_if_int (FALSE) __var__i __var__j) __var__j :ruleset array_api_ruleset) +(function Boolean___invert__ (Boolean) Boolean) +(rewrite (Boolean___invert__ (TRUE)) (FALSE) :ruleset array_api_ruleset) +(rewrite (Boolean___invert__ (FALSE)) (TRUE) :ruleset array_api_ruleset) +(ruleset ruleset_5218390416) +(function NDArray___eq__ (NDArray NDArray) NDArray) +(rewrite (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse __var__x) (Int___init__ 1)) (NDArray_scalar (Value_int __var__i))) (NDArray___eq__ __var__x (NDArray_scalar (NDArray_index (unique_values __var__x) (TupleInt_from_vec (vec-of __var__i))))) :subsume :ruleset ruleset_5218390416) +(function count_values (NDArray NDArray) TupleValue :unextractable) +(rewrite (TupleNDArray___getitem__ (unique_counts __var__x) (Int___init__ 1)) (NDArray_vector (count_values __var__x (unique_values __var__x))) :subsume :ruleset ruleset_5218390416) +(rewrite (count_values __var__x (NDArray_vector (TupleValue___add__ (TupleValue___init__ __var__v) __var__tv))) (TupleValue___add__ (TupleValue___init__ (NDArray_to_value (sum (NDArray___eq__ __var__x (NDArray_scalar __var__v)) (OptionalIntOrTuple_none)))) (count_values __var__x (NDArray_vector __var__tv))) :subsume :ruleset ruleset_5218390416) +(rewrite (count_values __var__x (NDArray_vector (TupleValue___init__ __var__v))) (TupleValue___init__ (NDArray_to_value (sum (NDArray___eq__ __var__x (NDArray_scalar __var__v)) (OptionalIntOrTuple_none)))) :subsume :ruleset ruleset_5218390416) +(function std (NDArray OptionalIntOrTuple) NDArray) +(sort IntOrTuple) +(function OptionalIntOrTuple_some (IntOrTuple) OptionalIntOrTuple) +(function IntOrTuple_int (Int) IntOrTuple) +(function ndarray-sqrt (NDArray) NDArray) +(function mean (NDArray OptionalIntOrTuple Boolean) NDArray) +(function square (NDArray) NDArray) +(rewrite (std __var__x (OptionalIntOrTuple_some (IntOrTuple_int __var__i))) (ndarray-sqrt (mean (square (NDArray___sub__ __var__x (mean __var__x (OptionalIntOrTuple_some (IntOrTuple_int __var__i)) (TRUE)))) (OptionalIntOrTuple_some (IntOrTuple_int __var__i)) (FALSE))) :subsume :ruleset ruleset_5218390416) +(rewrite (mean __var__x (OptionalIntOrTuple_some (IntOrTuple_int __var__i)) (FALSE)) (NDArray___truediv__ (sum __var__x (OptionalIntOrTuple_some (IntOrTuple_int __var__i))) (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape __var__x) __var__i)))) :subsume :ruleset ruleset_5218390416) +(function expand_dims (NDArray Int) NDArray) +(rewrite (mean __var__x (OptionalIntOrTuple_some (IntOrTuple_int __var__i)) (TRUE)) (expand_dims (NDArray___truediv__ (sum __var__x (OptionalIntOrTuple_some (IntOrTuple_int __var__i))) (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape __var__x) __var__i)))) __var__i) :subsume :ruleset ruleset_5218390416) +(function NDArray___matmul__ (NDArray NDArray) NDArray) +(function NDArray_var (String) NDArray :cost 200) +(function NDArray___setitem__ (NDArray IndexKey NDArray) NDArray) +(function zeros (TupleInt OptionalDType OptionalDevice) NDArray) +(function OptionalDType_some (DType) OptionalDType) +(sort Device) +(function OptionalDevice_some (Device) OptionalDevice) +(function NDArray_device (NDArray) Device) +(sort MultiAxisIndexKey) +(function IndexKey_multi_axis (MultiAxisIndexKey) IndexKey) +(sort MultiAxisIndexKeyItem) +(sort Vec_MultiAxisIndexKeyItem (Vec MultiAxisIndexKeyItem)) +(function MultiAxisIndexKey_from_vec (Vec_MultiAxisIndexKeyItem) MultiAxisIndexKey) +(function MultiAxisIndexKeyItem_int (Int) MultiAxisIndexKeyItem) +(sort Slice) +(function MultiAxisIndexKeyItem_slice (Slice) MultiAxisIndexKeyItem) +(function Slice___init__ (OptionalInt OptionalInt OptionalInt) Slice) +(function IndexKey_ndarray (NDArray) IndexKey) +(function NDArray___mul__ (NDArray NDArray) NDArray) +(function OptionalInt_some (Int) OptionalInt) +(function IndexKey_slice (Slice) IndexKey) +(simplify (saturate (seq (run array_api_ruleset) (run ruleset_5218390416))) (NDArray___getitem__ (NDArray___matmul__ (NDArray___sub__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___matmul__ (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0)))) (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))))) (NDArray___matmul__ (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 2)) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (NDArray_scalar (Value_float (Float___init__ 0.0001)))) (DType_int32)) (OptionalIntOrTuple_none))))) (OptionalInt_none))) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (NDArray___getitem__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (IndexKey_slice (Slice___init__ (OptionalInt_none) (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (NDArray_scalar (Value_float (Float___init__ 0.0001)))) (DType_int32)) (OptionalIntOrTuple_none))))) (OptionalInt_none))))) (NDArray___getitem__ (NDArray_T (TupleNDArray___getitem__ (svd (NDArray___matmul__ (NDArray_T (NDArray___mul__ (ndarray-sqrt (NDArray___mul__ (NDArray___mul__ (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)))) (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0))))) (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0)) (Int___init__ 1)))))))) (NDArray_T (NDArray___sub__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (NDArray___matmul__ (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0)))) (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE)))))))) (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 2)) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (NDArray_scalar (Value_float (Float___init__ 0.0001)))) (DType_int32)) (OptionalIntOrTuple_none))))) (OptionalInt_none))) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (NDArray___getitem__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (IndexKey_slice (Slice___init__ (OptionalInt_none) (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (NDArray_scalar (Value_float (Float___init__ 0.0001)))) (DType_int32)) (OptionalIntOrTuple_none))))) (OptionalInt_none)))))) (FALSE)) (Int___init__ 2))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___matmul__ (NDArray_T (NDArray___mul__ (ndarray-sqrt (NDArray___mul__ (NDArray___mul__ (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)))) (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0))))) (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0)) (Int___init__ 1)))))))) (NDArray_T (NDArray___sub__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (NDArray___matmul__ (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0)))) (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE)))))))) (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 2)) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (NDArray_scalar (Value_float (Float___init__ 0.0001)))) (DType_int32)) (OptionalIntOrTuple_none))))) (OptionalInt_none))) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (NDArray___getitem__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (IndexKey_slice (Slice___init__ (OptionalInt_none) (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (NDArray_scalar (Value_float (Float___init__ 0.0001)))) (DType_int32)) (OptionalIntOrTuple_none))))) (OptionalInt_none)))))) (FALSE)) (Int___init__ 1)) (NDArray___mul__ (NDArray_scalar (Value_float (Float___init__ 0.0001))) (NDArray___getitem__ (TupleNDArray___getitem__ (svd (NDArray___matmul__ (NDArray_T (NDArray___mul__ (ndarray-sqrt (NDArray___mul__ (NDArray___mul__ (NDArray_scalar (Value_int (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)))) (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0))))) (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0)) (Int___init__ 1)))))))) (NDArray_T (NDArray___sub__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (NDArray___matmul__ (NDArray___truediv__ (astype (TupleNDArray___getitem__ (unique_counts (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (NDArray_scalar (Value_float (Float___init__ 150.0)))) (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE)))))))) (NDArray___truediv__ (NDArray_T (NDArray___truediv__ (NDArray___getitem__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 2)) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (NDArray_scalar (Value_float (Float___init__ 0.0001)))) (DType_int32)) (OptionalIntOrTuple_none))))) (OptionalInt_none))) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (NDArray___getitem__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (IndexKey_slice (Slice___init__ (OptionalInt_none) (OptionalInt_some (Value_to_int (NDArray_to_value (sum (astype (NDArray___gt__ (TupleNDArray___getitem__ (svd (NDArray___mul__ (ndarray-sqrt (asarray (NDArray_scalar (Value_float (Float___truediv__ (Float___init__ 1.0) (Float_from_int (Int___sub__ (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none)))) (Int___init__ 0))))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (NDArray___truediv__ (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (NDArray___setitem__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (IndexKey_ndarray (NDArray___eq__ (std (concat (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 0)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___add__ (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 1)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))) (TupleNDArray___init__ (NDArray___sub__ (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (NDArray___getitem__ (unique_values (concat (TupleNDArray___init__ (unique_values (asarray (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalInt_none))) (IndexKey_int (Int___init__ 2)))))) (NDArray___getitem__ (NDArray___setitem__ (NDArray___setitem__ (NDArray___setitem__ (zeros (TupleInt_from_vec (vec-of (TupleInt___getitem__ (NDArray_shape (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 0))) (Int___init__ 0)) (TupleInt___getitem__ (NDArray_shape (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)))) (OptionalDType_some (NDArray_dtype (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)))) (OptionalDevice_some (NDArray_device (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 0)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 0)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 1)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 1)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none)))))) (mean (NDArray___getitem__ (asarray (assume_isfinite (assume_shape (assume_dtype (NDArray_var "X") (DType_float64)) (TupleInt_from_vec (vec-of (Int___init__ 150) (Int___init__ 4))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (IndexKey_ndarray (NDArray___eq__ (TupleNDArray___getitem__ (unique_inverse (asarray (reshape (asarray (assume_value_one_of (assume_shape (assume_dtype (NDArray_var "y") (DType_int64)) (TupleInt_from_vec (vec-of (Int___init__ 150)))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 0))) (TupleValue___add__ (TupleValue___init__ (Value_int (Int___init__ 1))) (TupleValue___init__ (Value_int (Int___init__ 2)))))) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none)) (TupleInt_from_vec (vec-of (Int___init__ -1))) (OptionalBool_none)) (OptionalDType_none) (OptionalBool_none) (OptionalDevice_none))) (Int___init__ 1)) (NDArray_scalar (Value_int (Int___init__ 2)))))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0))) (FALSE))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_int (Int___init__ 2)) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))))))))))) (OptionalInt_some (Int___init__ 0))) (OptionalIntOrTuple_some (IntOrTuple_int (Int___init__ 0)))) (NDArray_scalar (Value_int (Int___init__ 0))))) (NDArray_scalar (Value_float (Float___init__ 1.0)))))) (FALSE)) (Int___init__ 1)) (NDArray_scalar (Value_float (Float___init__ 0.0001)))) (DType_int32)) (OptionalIntOrTuple_none))))) (OptionalInt_none)))))) (FALSE)) (Int___init__ 1)) (IndexKey_int (Int___init__ 0))))) (DType_int32)) (OptionalIntOrTuple_none))))) (OptionalInt_none))))))))) (IndexKey_multi_axis (MultiAxisIndexKey_from_vec (vec-of (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_none) (OptionalInt_none))) (MultiAxisIndexKeyItem_slice (Slice___init__ (OptionalInt_none) (OptionalInt_some (Int___init__ 2)) (OptionalInt_none)))))))) diff --git a/tests/string.egg b/tests/string.egg new file mode 100644 index 0000000..74a879e --- /dev/null +++ b/tests/string.egg @@ -0,0 +1,8 @@ +; Tests for the string sort + +; Concatenation +(check (= (+ "a" "bc" "de") "abcde")) +; Counting the number of substring occurances +(check (= (count-matches "ab ab" "ab") 2)) +; replacing a substring +(check (= (replace "ab ab" "ab" "cd") "cd cd")) diff --git a/tests/string_quotes.csv b/tests/string_quotes.csv new file mode 100644 index 0000000..8baef1b --- /dev/null +++ b/tests/string_quotes.csv @@ -0,0 +1 @@ +abc diff --git a/tests/string_quotes.egg b/tests/string_quotes.egg new file mode 100644 index 0000000..6fca9d5 --- /dev/null +++ b/tests/string_quotes.egg @@ -0,0 +1,3 @@ +(function f () String) +(input f "tests/string_quotes.csv") +(check (= (f) "abc")) diff --git a/tests/subsume.egg b/tests/subsume.egg new file mode 100644 index 0000000..09adcf0 --- /dev/null +++ b/tests/subsume.egg @@ -0,0 +1,30 @@ +;; Let's pretend that we are optimizing mathematical expressions, but for some reason on our compiler +;; multiplying by three is very expensive. So we want to rewrite those forms to three additions instead, and always +;; extract that form. + +(datatype Math + (Num i64) + (Var String) + (Add Math Math) + (Mul Math Math)) + + +(rewrite (Mul (Num 3) x) (Add x (Add x x)) :subsume) + +(let x (Mul (Num 2) (Mul (Num 3) (Var "x")))) + +(run 10) + +; When X is extracted, we get the optimized form, where the * 3 is expanded out +(check (= x (Mul (Num 2) (Add (Var "x") (Add (Var "x") (Var "x")))))) +(extract x) +; Will be (Mul (Num 2) (Add (Var "x") (Add (Var "x") (Var "x")))) + +; Even though it can't be extracted, we can still check that x equal 2 * (3 * x) +(check (= x (Mul (Num 2) (Mul (Num 3) (Var "x"))))) + +; Also if we make multiplication commutative and run that run, we won't get that result either +; since the original expr has been subsumed when it was replaced with the addition +(rewrite (Mul x y) (Mul y x)) +(run 10) +(extract x) diff --git a/tests/terms.rs b/tests/terms.rs new file mode 100644 index 0000000..dc810a2 --- /dev/null +++ b/tests/terms.rs @@ -0,0 +1,33 @@ +use egglog::*; + +// This file tests the public API to terms. + +#[test] +fn test_termdag_public() { + let mut td = TermDag::default(); + let x = td.var("x".into()); + let seven = td.lit(7.into()); + let f = td.app("f".into(), vec![x, seven]); + assert_eq!(td.to_string(&f), "(f x 7)"); +} + +#[test] +#[should_panic] +fn test_termdag_malicious_client() { + // here is an example of how TermIds can be misused by passing + // them into the wrong DAG. + + let mut td = TermDag::default(); + let x = td.var("x".into()); + // at this point, td = [0 |-> x] + // snapshot the current td + let td2 = td.clone(); + let y = td.var("y".into()); + // now td = [0 |-> x, 1 |-> y] + let f = td.app("f".into(), vec![x.clone(), y.clone()]); + // f is Term::App("f", [0, 1]) + assert_eq!(td.to_string(&f), "(f x y)"); + // recall that td2 = [0 |-> x] + // notice that f refers to index 1, so this crashes: + td2.to_string(&f); +} diff --git a/tests/test-combined-steps.egg b/tests/test-combined-steps.egg new file mode 100644 index 0000000..059a34b --- /dev/null +++ b/tests/test-combined-steps.egg @@ -0,0 +1,53 @@ +; Step with alternating feet, left before right +(relation left (i64)) +(relation right (i64)) +(relation middle (i64)) + +(left 0) +(right 0) + +(ruleset step-left) +(rule ((left x) (right x)) + ((left (+ x 1))) + :ruleset step-left) + +(ruleset step-right) +(rule ((left x) (right y) (= x (+ y 1))) + ((right x)) + :ruleset step-right) + +(ruleset step-middle) +(rule ((left x)) + ((middle x)) + :ruleset step-middle) + +(unstable-combined-ruleset + my-combination + step-left step-right + step-middle) + +(run-schedule (repeat 1 my-combination)) + +(check (left 1)) +(check (right 0)) +;; middle didn't observe anything except original step +(check (middle 0)) +(fail (check (left 2))) +(fail (check (right 1))) +(fail (check (middle 1))) +(fail (check (middle 2))) + + +(run-schedule + (repeat 9 + (saturate step-right) + my-combination + (saturate step-right))) + +(check (left 10)) +(check (right 10)) +;; middle didn't get a chance to observe (left 10) +(check (middle 9)) +(fail (check (middle 10))) +(fail (check (left 11))) +(fail (check (right 11))) diff --git a/tests/test-combined.egg b/tests/test-combined.egg new file mode 100644 index 0000000..fa9df17 --- /dev/null +++ b/tests/test-combined.egg @@ -0,0 +1,33 @@ +(relation edge (i64 i64)) +(relation path (i64 i64)) + + +(ruleset myrules1) +(rule ((edge x y)) + ((path x y)) + :ruleset myrules1) +(ruleset myrules2) +(rule ((path x y) (edge y z)) + ((path x z)) + :ruleset myrules2) + +(unstable-combined-ruleset myrules-combined + myrules1 myrules2) + + +(edge 0 1) +(edge 1 2) +(edge 2 3) +(edge 2 4) + +(run-schedule + (repeat 3 myrules-combined)) + + +(check (path 0 1)) +(check (path 0 2)) +(check (path 0 3)) +(check (path 0 4)) +(check (path 1 2)) +(check (path 1 3)) +(check (path 1 4)) diff --git a/tests/towers-of-hanoi.egg b/tests/towers-of-hanoi.egg new file mode 100644 index 0000000..2b8d001 --- /dev/null +++ b/tests/towers-of-hanoi.egg @@ -0,0 +1,39 @@ +(datatype Stack + (Empty) + (Cons i64 Stack)) + +(function Config (Stack Stack Stack) i64 :merge (min old new)) + +;; move from first stack +(rule ((= len (Config (Cons x a) b c))) + ((set (Config a (Cons x b) c) (+ len 1)) + (set (Config a b (Cons x c)) (+ len 1)))) + +;; move from second stack +(rule ((= len (Config a (Cons x b) c))) + ((set (Config (Cons x a) b c) (+ len 1)) + (set (Config a b (Cons x c)) (+ len 1)))) + +;; move from third stack +(rule ((= len (Config a b (Cons x c)))) + ((set (Config (Cons x a) b c) (+ len 1)) + (set (Config a (Cons x b) c) (+ len 1)))) + +(let e (Empty)) + + +;; initial state [123 _ _] with path "length" 0 +(set (Config (Cons 1 (Cons 2 (Cons 3 e))) e e) 0) + +;; find all reachable states +(run 1000000) + +;; print first 10 tuples +(print-function Config 10) +(print-size Config) + +;; how to long to move to state [_ _ 123] +(query-extract (Config e e (Cons 1 (Cons 2 (Cons 3 e))))) + +;; actually do the assertion +(check (= 5 (Config e e (Cons 1 (Cons 2 (Cons 3 e)))))) \ No newline at end of file diff --git a/tests/tricky-type-checking.egg b/tests/tricky-type-checking.egg new file mode 100644 index 0000000..c791006 --- /dev/null +++ b/tests/tricky-type-checking.egg @@ -0,0 +1,138 @@ +;;;;;;;;;;;;;;;;;; +;; From repro-constraineq + +;; repro-constraineq +(push) +(rule ((= x 1) (= y x) (= z y)) ()) +(run 1) +(pop) + +;; repro-constraineq2 +(push) +(rule ((= x 1) (= y x)) ()) +(run 1) +(pop) + +;; repro-constraineq3 +(push) +(relation f (i64)) + +(rule ((= x 1) + (= x 2)) + ((f x))) + +(run 1) +(print-function f 10) +(pop) + +;;;;;;;;;;;;;;;;;; +;; Atoms need to be order-insensitive + +;; Issue #196 +(push) +(relation R (i64)) + +(rule + ((= x y) + (= y 1)) + ((R x))) +(run 1) +(check (R 1)) +(pop) + +(push) +(relation R (i64)) + +(rule + ((= x (+ y 1)) + (= y 1)) + ((R x))) +(run 1) +(check (R 2)) +(pop) + +;; Issue #80 +(push) +(datatype TYPE) +(datatype TERM) +(function type (TERM) TYPE) +(function Ob () TYPE) +(function Hom (TERM TERM) TYPE) + +(function id (TERM) TERM) +(rule ((type (id A))) + ((type A))) +(rewrite (type (id A)) + (Hom A A) + :when ((= (type A) (Ob)))) + +(function compose (TERM TERM) TERM) +(rule ((type (compose f g))) + ((type f) + (type g))) +(rewrite (type (compose f g)) + (Hom A C) + :when ((= (type f) (Hom A B)) + (= (type g) (Hom B C)))) + +(birewrite (compose (compose f g) h) + (compose f (compose g h)) + :when ((= (type A) (Ob)) + (= (type B) (Ob)) + (= (type C) (Ob)) + (= (type D) (Ob)) + (= (type f) (Hom A B)) + (= (type g) (Hom B C)) + (= (type h) (Hom C D)))) +(birewrite (compose f (id B)) f + :when ((= (type A) (Ob)) + (= (type B) (Ob)) + (= (type f) (Hom A B)))) +(birewrite (compose (id A) f) f + :when ((= (type A) (Ob)) + (= (type B) (Ob)) + (= (type f) (Hom A B)))) + +(function AConst () TERM) +(let A (AConst)) +(function BConst () TERM) +(let B (BConst)) +(function fConst () TERM) +(let f (fConst)) +(function gConst () TERM) +(let g (gConst)) +(let fog (compose g f)) +(union (type f) (Hom A B)) +(union (type g) (Hom B A)) +(union (type A) (Ob)) +(union (type B) (Ob)) +(type fog) +(run 10) +(print-function type 10) +(check (= (type f) + (type (compose (id A) + (compose f (id B)))))) +(check (= (type fog) + (Hom B B))) +(pop) + + +;;;;;;;;;;;;;;;;;; +;; Finding the right type in case of container types and primitives + +;; Issue #113 + +(push) +(sort MyMap (Map i64 String)) +(sort MyMap1 (Map i64 i64)) + +(let my_map1 (map-insert (map-empty) 1 "one")) +(pop) + +(push) +(sort MyMap1 (Map i64 i64)) +(sort MyMap (Map i64 String)) + +(let my_map1 (map-insert (map-empty) 1 "one")) +(pop) + diff --git a/tests/type-constraints-tests.egg b/tests/type-constraints-tests.egg new file mode 100644 index 0000000..63c8053 --- /dev/null +++ b/tests/type-constraints-tests.egg @@ -0,0 +1,10 @@ +(datatype Operand) +(sort VecOperandBase (Vec Operand)) +(datatype VecOperand (VO VecOperandBase)) +(sort VecVecOperandBase (Vec VecOperand)) + +(rule + ((= v1 (vec-of)) + (= v2 (VO v1)) + (= v3 (vec-of v2))) + ()) diff --git a/tests/typecheck.egg b/tests/typecheck.egg new file mode 100644 index 0000000..886a9c4 --- /dev/null +++ b/tests/typecheck.egg @@ -0,0 +1,102 @@ +; type checking for simply typed lambda calculus + +(datatype Type + (TArr Type Type) ; t1 -> t2 +) +(function TUnitConst () Type) +(let TUnit (TUnitConst)) + +(datatype Expr + (Lam String Type Expr) ; lam x : t . e + (App Expr Expr) + (Var String) +) +(function MyUnitConst () Expr) +(let MyUnit (MyUnitConst)) + +(datatype Ctx + (Cons String Type Ctx) +) +(function NilConst () Ctx) +(let Nil (NilConst)) + +; ctx |- expr : type +(function typeof (Ctx Expr) Type) + +; ctx |- () : unit +(rewrite (typeof ctx MyUnit) TUnit) + +; ctx; x: t |- x : t +(rewrite (typeof (Cons x t ctx) (Var x)) t) + +; ctx |- f :- t1 -> t2 +; ctx |- e : t1 +; ----------------- +; ctx |- f e : t2 + +(rule ( + (= (typeof ctx (App f e)) t2) +)( + (typeof ctx f) + (typeof ctx e) +)) + +(rule ( + (= (typeof ctx (App f e)) t1) + (= (typeof ctx f) (TArr (typeof ctx e) t2)) +)( + (union t1 t2) +)) + +; ctx |- x : t +; ------------------ y != x +; ctx; y: t |- x : t + +(rewrite (typeof (Cons y ty ctx) (Var x)) + (typeof ctx (Var x)) + :when ((!= x y))) + +; ctx; x: t1 |- e : t2 +; ------------------------------ +; ctx |- lam x: t1. e : t1 -> t2 + +; rhs of rewrite creates demand +(rewrite (typeof ctx (Lam x t1 e)) + (TArr t1 (typeof (Cons x t1 ctx) e))) + +; TEST +; ---- + +; lam x : unit, f : unit -> unit . f x +(let e + (Lam "x" TUnit + (Lam "f" (TArr TUnit TUnit) + (App (Var "f") (Var "x"))))) + +; lam x : unit . x +(let id (Lam "x" TUnit (Var "x"))) +(let t-id (typeof Nil id)) + +; (e () id) = () +(let app-unit-id (App (App e MyUnit) id)) +(let t-app (typeof Nil app-unit-id)) + +(let free (Lam "x" TUnit (Var "y"))) +(let t-free-ill (typeof Nil free)) +(let t-free-1 (typeof (Cons "y" TUnit Nil) free)) +(let t-free-2 (typeof (Cons "y" (TArr (TArr TUnit TUnit) TUnit) Nil) free)) + +(run 15) + +(query-extract t-id) +(check (= t-id (TArr TUnit TUnit))) + +(query-extract t-app) +(check (= t-app TUnit)) + +(query-extract t-free-1) +(check (= t-free-1 (TArr TUnit TUnit))) +(query-extract t-free-2) +(check (= t-free-2 (TArr TUnit (TArr (TArr TUnit TUnit) TUnit)))) +; this will err +; (query-extract t-free-ill) diff --git a/tests/typeinfer.egg b/tests/typeinfer.egg new file mode 100644 index 0000000..d7d7e42 --- /dev/null +++ b/tests/typeinfer.egg @@ -0,0 +1,337 @@ +;;;;;;;;;;;;;;;;;;;;;; +;; Exprs and Types +;;;;;;;;;;;;;;;;;;;;;; + +(datatype Ident) +(datatype Expr) +(datatype Type) +(datatype Scheme) +(datatype Ctx) +;; TODO: can't do unit right now +(sort QuantifiedVs (Set Ident)) + +(function Fresh (Ident i64) Ident) +(function V (String) Ident) + +(function Var (Ident) Expr) +(function App (Expr Expr) Expr) +(function Abs (Ident Expr) Expr) +(function Let (Ident Expr Expr) Expr) +(function Num (i64) Expr) +(function True () Expr) +(function False () Expr) +(function MyUnit () Expr) + +(function TVar (Ident) Type :cost 3) +(function TArr (Type Type) Type :cost 1) +(function TInt () Type :cost 1) +(function TBool () Type :cost 1) +(function TUnit () Type :cost 1) + +(function Forall (QuantifiedVs Type) Scheme) +(function Nil () Ctx) +(function Cons (Ident Scheme Ctx) Ctx) + +(relation ftvCtx (Ctx QuantifiedVs)) +(relation ftv (Type QuantifiedVs)) +(relation ftvScheme (Scheme QuantifiedVs)) +(relation has-qs (Ctx Type QuantifiedVs)) +(relation has-qs-demand (Ctx Type)) + +;;;;;;;;;;;;;;;;;;;;;; +;; Expression size +;;;;;;;;;;;;;;;;;;;;;; +(relation expr-size (Expr i64)) +(rule ((= e (Num n)))((expr-size e 1))) +(rule ((= e (Var x)))((expr-size e 1))) +;; asserted facts will be cleared so we define them as rules +(rule ((= e (True))) ((expr-size e 1))) +(rule ((= e (False))) ((expr-size e 1))) +(rule ((= e (MyUnit))) ((expr-size e 1))) +(rule ((= e (App e1 e2)) + (expr-size e1 s1) + (expr-size e2 s2)) + ((expr-size e (+ (+ s1 s2) 1)))) +(rule ((= e (Let x e1 e2)) + (expr-size e1 s1) + (expr-size e2 s2)) + ((expr-size e (+ (+ s1 s2) 1)))) +(rule ((= e (Abs x e1)) + (expr-size e1 s1)) + ((expr-size e (+ s1 1)))) + +;;;;;;;;;;;;;;;;;;;;;; +;; Scheme and Context +;;;;;;;;;;;;;;;;;;;;;; + +(rule ((= e (TBool)))((ftv e (set-empty)))) +(rule ((= e (TUnit)))((ftv e (set-empty)))) +(rule ((= e (TInt)))((ftv e (set-empty)))) +(rule ((= e (TVar x)))((ftv e (set-insert (set-empty) x)))) +(rule ((= e (TArr fr to)) + (ftv fr s1) + (ftv to s2)) + ((ftv e (set-union s1 s2)))) +(rule ((= c (Nil))) ((ftvCtx c (set-empty)))) +(rule ((= e (Forall qs t)) + (ftv t fvs)) + ((ftvScheme e (set-diff fvs qs)))) +(rule ((= c (Cons x s n)) + (ftvCtx n fvs1) + (ftvScheme s fvs2)) + ((ftvCtx c (set-union fvs1 fvs2)))) + + +;; TODO: rewrite lookup to use native sets +(function lookup (Ctx Ident) Scheme :cost 1000) +(rewrite (lookup (Cons x s tl) x) s) +(rule ( + (= t (lookup (Cons y s tl) x)) + (!= x y) +)( + (union t (lookup tl x)) +)) + +;;;;;;;;;;;;;;;;;;;;;; +;; Generalization and Instantiation +;;;;;;;;;;;;;;;;;;;;;; + +(function generalize (Ctx Type) Scheme :cost 1000) +(function instantiate (Scheme i64) Type :cost 1000) + +(rule ((has-qs-demand ctx (TInt))) + ((has-qs ctx (TInt) (set-empty)))) +(rule ((has-qs-demand ctx (TBool))) + ((has-qs ctx (TBool) (set-empty)))) +(rule ((has-qs-demand ctx (TUnit))) + ((has-qs ctx (TUnit) (set-empty)))) + +(rule ((has-qs-demand ctx (TArr fr to))) + ((has-qs-demand ctx fr) + (has-qs-demand ctx to))) +(rule ((has-qs-demand ctx (TArr fr to)) + (has-qs ctx fr qs1) + (has-qs ctx to qs2)) + ((has-qs ctx (TArr fr to) (set-union qs1 qs2)))) + +(rule ((has-qs-demand ctx (TVar x)) + (ftvCtx ctx key-set) + (set-contains key-set x)) + ((has-qs ctx (TVar x) (set-empty)))) +(rule ((has-qs-demand ctx (TVar x)) + (ftvCtx ctx key-set) + (set-not-contains key-set x)) + ((has-qs ctx (TVar x) (set-insert (set-empty) x)))) + +(rule ((= sc (generalize ctx t))) + ((has-qs-demand ctx t))) +(rewrite (generalize ctx t) + (Forall qs t) + :when ((has-qs ctx t qs))) + +(function subst-fresh (QuantifiedVs Type i64) Type :cost 1000) +(rewrite (subst-fresh vs (TInt) c) (TInt)) +(rewrite (subst-fresh vs (TBool) c) (TBool)) +(rewrite (subst-fresh vs (TUnit) c) (TUnit)) +(rewrite (subst-fresh vs (TArr fr to) c) + (TArr (subst-fresh vs fr c) (subst-fresh vs to c))) +(rule ((= otype (subst-fresh vs (TVar s) c)) + (set-contains vs s)) + ((union otype (TVar (Fresh s c))))) +(rule ((= otype (subst-fresh vs (TVar s) c)) + (set-not-contains vs s)) + ((union otype (TVar s)))) + +(rewrite (instantiate (Forall vs t) c) + (subst-fresh vs t c)) + +;;;;;;;;;;;;;;;;;;;;;; +;; Injectivity +;;;;;;;;;;;;;;;;;;;;;; + +(rule ((= (TArr fr1 to1) (TArr fr2 to2))) + ((union fr1 fr2) + (union to1 to2))) + +;;;;;;;;;;;;;;;;;;;;;; +;; Type inference +;;;;;;;;;;;;;;;;;;;;;; + +; ctx |- expr : type +(function typeof (Ctx Expr i64) Type :cost 1000) + +;; Basic types (TInt, TBool, TUnit) +(rewrite (typeof ctx (Num x) c) (TInt)) +(rewrite (typeof ctx (True) c) (TBool)) +(rewrite (typeof ctx (False) c) (TBool)) +(rewrite (typeof ctx (MyUnit) c) (TUnit)) + +; sc = lookup(ctx, x) +; t = instantiate(sc) +; --------------- +; ctx |- x : t +(rewrite (typeof ctx (Var x) c) + (instantiate (lookup ctx x) c)) + +(rewrite + (typeof ctx (Abs x e) c) + (TArr (TVar (Fresh x c)) + (typeof (Cons x (Forall (set-empty) (TVar (Fresh x c))) + ctx) + e cc)) + :when ((= cc (+ c 1)))) + +(rule ((= to (typeof ctx (App e1 e2) c)) + (= c1 (+ c 1)) + (expr-size e1 sz) + (= c2 (+ c (+ sz 1)))) + ((union (typeof ctx e1 c1) + (TArr (typeof ctx e2 c2) to)))) + +(rewrite (typeof ctx (Let x e1 e2) c) + (typeof (Cons x (generalize ctx (typeof ctx e1 c1)) + ctx) + e2 c2) + :when ((= c1 (+ c 1)) + (expr-size e1 sz) + (= c2 (+ c (+ sz 1))))) + +;;;;;;;;;;;;;;;;;;;;;; +;; Occurs check +;;;;;;;;;;;;;;;;;;;;;; +(relation occurs-check (Ident Type)) +(function errors () Ident) +(rule ((= (TVar x) (TArr fr to))) + ((occurs-check x fr) + (occurs-check x to))) +(rule ((occurs-check x (TVar x))) + ;; ((set (errors) x))) + ((panic "occurs check fail"))) +(rule ((occurs-check x (TArr fr to))) + ((occurs-check x fr) + (occurs-check x to))) + +(relation base-types (Type)) +(base-types (TInt)) +(base-types (TBool)) +(base-types (TUnit)) +(rule ((base-types t) + (= t (TArr fr to))) + ((panic "Unifying base types with functions")) ) +(rule ((= (TInt) (TBool))) ((panic "Unifying base types"))) +(rule ((= (TInt) (TUnit))) ((panic "Unifying base types"))) +(rule ((= (TBool) (TUnit))) ((panic "Unifying base types"))) +;;;;;;;;;;;;;;;;;;;;;; +;; TEST +;;;;;;;;;;;;;;;;;;;;;; + +(push) +(let id (Abs (V "x") (Var (V "x")))) +(let t-id (typeof (Nil) id 0)) +(run 100) +(check (= t-id (TArr (TVar (Fresh (V "x") 0)) (TVar (Fresh (V "x") 0))))) +(pop) + +(push) +(let let-poly (Let (V "id") (Abs (V "x") (Var (V "x"))) + (App (App (Var (V "id")) (Var (V "id"))) + (App (Var (V "id")) (True))))) +(let t-let-poly (typeof (Nil) let-poly 0)) +(run 100) +(check (= t-let-poly (TBool))) +(pop) + +(push) +(let id-id (App (Abs (V "x") (Var (V "x"))) + (Abs (V "y") (Var (V "y"))))) +(let t-id-id (typeof (Nil) id-id 0)) +(run 100) +(check (= t-id-id (TArr (TVar (Fresh (V "y") 3)) (TVar (Fresh (V "y") 3))))) +(pop) + + +(push) +(let let-true (Let (V "x") (True) (True))) +(let t-let-true (typeof (Nil) let-true 0)) +(run 100) +(check (= t-let-true (TBool))) +(pop) + +(push) + +(let let-var-true (Let (V "x") (True) (Var (V "x")))) +(let t-let-var-true (typeof (Nil) let-var-true 0)) +(run 100) +(check (= t-let-var-true (TBool))) +(pop) + +(push) + +(let abs-id (Abs (V "x") + (Let (V "y") (Abs (V "z") (Var (V "z"))) (Var (V "y"))))) +(let t-abs-id (typeof (Nil) abs-id 0)) +(run 100) +(let x (Fresh (V "x") 0)) +(let z (Fresh (Fresh (V "z") 2) 4)) +(check (= t-abs-id (TArr (TVar x) (TArr (TVar z) (TVar z))))) +(pop) + +(push) + +(let let-env (Let (V "x") (True) + (Let (V "f") (Abs (V "a") (Var (V "a"))) + (Let (V "x") (MyUnit) + (App (Var (V "f")) (Var (V "x"))) + )))) +(let t-let-env (typeof (Nil) let-env 0)) +(run 100) +(check (= t-let-env (TUnit))) +(pop) + +(push) +(let let-env-2a (Let (V "x") (MyUnit) + (Let (V "f") (Abs (V "y") (Var (V "x"))) + (Let (V "x") (True) + (App (Var (V "f")) (Var (V "x"))))))) +(let t-let-env-2a (typeof (Nil) let-env-2a 0)) +(run 100) +(check (= t-let-env-2a (TUnit))) +(pop) + +(push) + +(let let-env-2b (App (Abs (V "x") + (Let (V "f") (Abs (V "y") (Var (V "x"))) + (Let (V "x") (True) + (App (Var (V "f")) (Var (V "x")))))) + (MyUnit))) +(let t-let-env-2b (typeof (Nil) let-env-2b 0)) +(run 100) +(check (= t-let-env-2b (TUnit))) +(pop) + +(push) + +;; ((lambda (x) ((lambda (f) ((lambda (x) (f x)) #t)) (lambda (y) x))) 5) +(let let-env-hard (App (Abs (V "x") + (App (Abs (V "f") + (App (Abs (V "x") (App (Var (V "f")) (Var (V "x")))) + (True))) + (Abs (V "y") (Var (V "x"))))) + (MyUnit))) +(let t-let-env-hard (typeof (Nil) let-env-hard 0)) +(run 100) +(check (= t-let-env-hard (TUnit))) +(pop) + +(push) + +(let let-inst (Let (V "id") (Abs (V "x") (Var (V "x"))) + (Let (V "iid") (Abs (V "y") (Var (V "id"))) + (App (Var (V "iid")) + (App (Var (V "id")) (True))))) ) +(let t-let-inst (typeof (Nil) let-inst 0)) +(run 100) +(check (= t-let-inst (TArr (TVar (Fresh (Fresh (Fresh (V "x") 1) 5) 7)) (TVar (Fresh (Fresh (Fresh (V "x") 1) 5) 7))))) +(pop) + diff --git a/tests/unification-points-to.egg b/tests/unification-points-to.egg new file mode 100644 index 0000000..9526735 --- /dev/null +++ b/tests/unification-points-to.egg @@ -0,0 +1,243 @@ +(datatype FuncT (Func String)) +(datatype StmtT (Stmt String)) +(datatype ExprT (Expr String)) +(datatype FieldT (Field String)) +(datatype TypeT (Type String)) +(datatype AllocT (Alloc AllocT) (AllocVar ExprT)) + +(relation func (FuncT ExprT TypeT TypeT)) +(relation func-stmt (FuncT StmtT)) +(relation assign (StmtT TypeT ExprT ExprT)) +(relation field-assign (StmtT ExprT FieldT ExprT)) +(relation store (StmtT ExprT ExprT)) +(relation expr (StmtT ExprT)) +(relation return (StmtT ExprT)) +(relation eq (ExprT ExprT ExprT)) +(relation call (ExprT FuncT ExprT)) +(relation add (ExprT ExprT ExprT)) +(relation field (ExprT ExprT FieldT)) +(relation struct-lit-field (ExprT FieldT ExprT)) +(relation addr (ExprT ExprT FieldT)) +(relation load (ExprT ExprT)) +(relation malloc (ExprT TypeT)) + +;; typedef struct s { +;; int x; +;; int y; +;; } s; + +;; int mul(struct s q) { ... } + +;; int fact(int i) { +;; int c = i == 0; +;; if (c) { +;; return 1; +;; } else { +;; int j = i + -1; +;; int r = fact(j); +;; int prod = mul((struct s){i, r}); +;; return prod; +;; } +;; } +;; (func (Func "fact") (Expr "i") (Type "int") (Type "int")) +;; (func-stmt (Func "fact") (Stmt "int c = i == 0;")) +;; (func-stmt (Func "fact") (Stmt "if ...")) +;; (func-stmt (Func "fact") (Stmt "return 1")) +;; (func-stmt (Func "fact") (Stmt "int j = i + -1")) +;; (func-stmt (Func "fact") (Stmt "int r = fact(j)")) +;; (func-stmt (Func "fact") (Stmt "int prod = mul({ x: i, y: r })")) +;; (func-stmt (Func "fact") (Stmt "return prod")) +;; (assign (Stmt "int c = i == 0") (Type "int") (Expr "c") (Expr "i == 0")) +;; (assign (Stmt "int j = i + -1") (Type "int") (Expr "j") (Expr "i + -1")) +;; (assign (Stmt "int r = fact(j)") (Type "int") (Expr "r") (Expr "fact(j)")) +;; (assign (Stmt "int prod = mul({ x: i, y: r })") (Type "int") (Expr "prod") (Expr "mul({ x: i, y: r })")) +;; (eq (Expr "i == 0") (Expr "i") (Expr "0")) +;; (add (Expr "i + -1") (Expr "i") (Expr "-1")) +;; (call (Expr "fact(j)") (Func "fact") (Expr "j")) +;; (call (Expr "mul({ x: i, y: r })") (Func "mul") (Expr "{ x: i, y: r }")) +;; (return (Stmt "return prod") (Expr "prod")) + +;; typedef struct s { +;; int *x; +;; int *y; +;; } s; + +;; void swap(struct s *r) { +;; int **xp = &(r->x); +;; int **yp = &(r->y); +;; int *a = *xp; +;; int *b = *yp; +;; *xp = a; +;; *yp = b; +;; } + +;; int f(int i) { +;; struct s *sp = malloc(sizeof(struct s)); +;; int *u = malloc(sizeof(int)); +;; int *v = malloc(sizeof(int)); +;; *u = i; +;; *v = i; +;; *sp = (struct s){u, v}; +;; swap(sp); +;; int **zpp = &(sp->x); +;; int *zp = *zpp; +;; return *zp; +;; } +(func (Func "swap") (Expr "r") (Type "void") (Type "{int *x; int *y;}*")) +;; statements +(func-stmt (Func "swap") (Stmt "int **xp = &(r->x)")) +(func-stmt (Func "swap") (Stmt "int **yp = &(r->y)")) +(func-stmt (Func "swap") (Stmt "int *z = *xp")) +(func-stmt (Func "swap") (Stmt "int *w = *yp")) +(func-stmt (Func "swap") (Stmt "*xp = a")) +(func-stmt (Func "swap") (Stmt "*yp = b")) +(assign (Stmt "int **xp = &(r->x)") (Type "int **") (Expr "xp") (Expr "&(r->x)")) +(assign (Stmt "int **yp = &(r->x)") (Type "int **") (Expr "yp") (Expr "&(r->y)")) +(assign (Stmt "int *a = *xp") (Type "int *") (Expr "a") (Expr "*xp")) +(assign (Stmt "int *b = *yp") (Type "int *") (Expr "b") (Expr "*yp")) +(store (Stmt "*xp = a") (Expr "xp") (Expr "a")) +(store (Stmt "*yp = b") (Expr "yp") (Expr "b")) +;; expressions +(addr (Expr "&(r->x)") (Expr "r") (Field "x")) +(addr (Expr "&(r->y)") (Expr "r") (Field "y")) +(load (Expr "*xp") (Expr "xp")) +(load (Expr "*yp") (Expr "yp")) + +(func (Func "f") (Expr "i") (Type "int") (Type "int")) +;; statements +(func-stmt (Func "f") (Stmt "struct s *sp = malloc(sizeof(struct s))")) +(func-stmt (Func "f") (Stmt "int *u = malloc(sizeof(int))")) +(func-stmt (Func "f") (Stmt "int *v = malloc(sizeof(int))")) +(func-stmt (Func "f") (Stmt "*u = i")) +(func-stmt (Func "f") (Stmt "*v = i")) +(func-stmt (Func "f") (Stmt "*sp = (struct s){u, v}")) +(func-stmt (Func "f") (Stmt "swap(sp)")) +(func-stmt (Func "f") (Stmt "int **zpp = &(sp->x)")) +(func-stmt (Func "f") (Stmt "int *zp = *zpp")) +(func-stmt (Func "f") (Stmt "return *zp")) +(assign (Stmt "struct s *sp = malloc(sizeof(struct s))") (Type "struct s*") (Expr "sp") (Expr "malloc(sizeof(struct s))")) +(assign (Stmt "int *u = malloc(sizeof(int))") (Type "int *") (Expr "u") (Expr "malloc(sizeof(int))")) +(assign (Stmt "int *v = malloc(sizeof(int))") (Type "int *") (Expr "v") (Expr "malloc(sizeof(int))")) +(store (Stmt "*u = i") (Expr "u") (Expr "i")) +(store (Stmt "*v = i") (Expr "v") (Expr "i")) +(store (Stmt "*sp = (struct s){u, v}") (Expr "sp") (Expr "(struct s){u, v}")) +(expr (Stmt "swap(sp)") (Expr "swap(sp)")) +(assign (Stmt "int **zpp = &(sp->x)") (Type "int **") (Expr "zpp") (Expr "&(sp->x)")) +(assign (Stmt "int *zp = *zpp") (Type "int *") (Expr "zp") (Expr "*zpp")) +(return (Stmt "return *zp") (Expr "*zp")) +;; expressions +(malloc (Expr "malloc(sizeof(struct s))") (Type "struct s")) +(malloc (Expr "malloc(sizeof(int))") (Type "int")) +(struct-lit-field (Expr "(struct s){u, v}") (Field "x") (Expr "u")) +(struct-lit-field (Expr "(struct s){u, v}") (Field "y") (Expr "v")) +(call (Expr "swap(sp)") (Func "swap") (Expr "sp")) +(addr (Expr "&(sp->x)") (Expr "sp") (Field "x")) +(load (Expr "*zpp") (Expr "zpp")) +(load (Expr "*zp") (Expr "zp")) + +;; a variable points to its allocation +(function expr-points-to (ExprT) AllocT) +(function ptr-points-to (AllocT) AllocT) + +;; If `v = malloc(...)`, then `v -> alloc[v]`. +(rule ( + (assign s t1 v c) + (malloc c t2) +)( + (union (expr-points-to v) (AllocVar v)) +)) + +;; If `t v = e` and `e -> a`, then `v -> a`. +(rule ( + (assign s t v e) + (= (expr-points-to e) a) +)( + (union (expr-points-to v) a) +)) + +;; If `*v = u`, `v -> a`, and `u -> b`, then `a -> b`. +(rule ( + (store s v u) + (= (expr-points-to v) a) + (= (expr-points-to u) b) +)( + (union (ptr-points-to a) b) +)) + +;; If `e.f -> a` then `e -> a`. +(rule ( + (field ef e f) + (= (expr-points-to ef) a) +)( + (union (expr-points-to e) a) +)) + +;; If `e -> a` then `e.f -> a`. +(rule ( + (= (expr-points-to e) a) + (field ef e f) +)( + (union (expr-points-to ef) a) +)) + +;; If `u -> a` and `a -> b`, then `&(u->f) -> b`. +(rule ( + (= (expr-points-to u) a) + (= (ptr-points-to a) b) + (addr e u f) +)( + (union (expr-points-to e) b) +)) + +;; If `u -> a` and `&(u->f) -> b`, then `a -> b`. +(rule ( + (= (expr-points-to u) a) + (addr e u f) + (= (expr-points-to e) b) +)( + (union (ptr-points-to a) b) +)) + +;; If `(struct t){..., x, ...}` and `x -> b`, then `(struct t){..., x, ...} -> b`. +(rule ( + (struct-lit-field l f x) + (= (expr-points-to x) b) +)( + (union (expr-points-to l) b) +)) + +;; If `f(t* x)`, `f(v)`, and `v -> a`, then `x -> a`. +(rule ( + (func f x in out) + (call e f v) + (= (expr-points-to v) a) +)( + (union (expr-points-to x) a) +)) + +;; If `return u` in `f` and `u -> a`, then `f(z) -> a`. +(rule ( + (call e f v) + (func-stmt f s) + (return s u) + (= (expr-points-to u) a) +)( + (union (expr-points-to e) a) +)) + +;; store rule +(rule ( + (load e u) + (= (expr-points-to u) a) + (= (ptr-points-to a) b) +)( + (union (expr-points-to e) b) +)) + +(run 40) + +(check (= (AllocVar (Expr "v")) (AllocVar (Expr "u")))) +(check (!= (AllocVar (Expr "v")) (AllocVar (Expr "sp")))) + +(query-extract :variants 100 (AllocVar (Expr "u"))) +(query-extract :variants 100 (AllocVar (Expr "sp"))) diff --git a/tests/unify.egg b/tests/unify.egg new file mode 100644 index 0000000..59e3be4 --- /dev/null +++ b/tests/unify.egg @@ -0,0 +1,26 @@ +(datatype Expr + (Mul Expr Expr) + (Var String) + (Lit i64) +) + +; Assume injectivity of Mul for unification +(rule ((= (Mul a b) (Mul c d))) + ((union a c) + (union b d))) + +;; (relation False (i64)) +; If any Literal make equal to something it can't be, false is derived +;(rule ((= (Lit i) (Lit j)) (!= i j)) +; ((False 0))) +(rule ((= (Lit i) (Mul a b))) + ((panic "Literal cannot be equal to a product"))) + +(union (Mul (Var "a") (Var "a")) + (Mul (Lit 1) (Lit 2))) + + +(run 3) +(check (= (Var "a") (Lit 1))) +(check (= (Lit 2) (Lit 1))) +; (check (False 0)) ;; this should fail because we don't want prove false \ No newline at end of file diff --git a/tests/unstable-fn.egg b/tests/unstable-fn.egg new file mode 100644 index 0000000..a4471d9 --- /dev/null +++ b/tests/unstable-fn.egg @@ -0,0 +1,70 @@ +(datatype Math + (Num i64) + (Var String) + (Add Math Math) + (Mul Math Math)) + +(rewrite (Mul (Num x) (Num y)) (Num (* x y))) + +(datatype MathList + (Nil) + (Cons Math MathList)) + +(sort MathFn (UnstableFn (Math) Math)) + + +(function square (Math) Math) +(rewrite (square x) (Mul x x)) + +(let square-fn (unstable-fn "square" )) + +;; test that we can call a function +(let squared-3 (unstable-app square-fn (Num 3))) +(check (= squared-3 (square (Num 3)))) + +;; test that we can apply a function to a list + +(function list-map-math (MathList MathFn) MathList) +(rewrite (list-map-math (Nil) fn) (Nil)) +(rewrite (list-map-math (Cons x xs) fn) (Cons (unstable-app fn x) (list-map-math xs fn))) + +(let x (Cons (Num 1) (Cons (Num 2) (Cons (Num 3) (Nil))))) +(let squared-x (list-map-math x square-fn)) +(run-schedule (saturate (run))) +(check (= squared-x (Cons (Num 1) (Cons (Num 4) (Cons (Num 9) (Nil)))))) + +;; Test that we can partially apply a function in a rewrite rule + +(function list-multiply-by (MathList Math) MathList) +(rewrite (list-multiply-by l i) (list-map-math l (unstable-fn "Mul" i))) + +(let doubled-x (list-multiply-by x (Num 2))) +(run-schedule (saturate (run))) +(check (= doubled-x (Cons (Num 2) (Cons (Num 4) (Cons (Num 6) (Nil)))))) + +;; Test we can define a higher order compose function + +(function composed-math (MathFn MathFn Math) Math) +(rewrite (composed-math f g v) (unstable-app f (unstable-app g v))) + +(let square-of-double (unstable-fn "composed-math" square-fn (unstable-fn "Mul" (Num 2)))) + +(let squared-doubled-x (list-map-math x square-of-double)) +(run-schedule (saturate (run))) +(check (= squared-doubled-x (Cons (Num 4) (Cons (Num 16) (Cons (Num 36) (Nil)))))) + + +;; See that it supports primitive values as well +(sort i64Fun (UnstableFn (i64) i64)) + +(function composed-i64-math (MathFn i64Fun i64) Math) +(rewrite (composed-i64-math f g v) (unstable-app f (Num (unstable-app g v)))) + +(let res (composed-i64-math square-fn (unstable-fn "*" 2) 4)) +(run-schedule (saturate (run))) +(check (= res (Num 64))) + +;; Verify that function parsing works with a function with no args +(sort TestNullaryFunction (UnstableFn () Math)) +;; Verify that we know the type of a function based on the string name +(extract (unstable-fn "square")) diff --git a/tests/until.egg b/tests/until.egg new file mode 100644 index 0000000..24c3a51 --- /dev/null +++ b/tests/until.egg @@ -0,0 +1,34 @@ +; A simple group +(datatype G) +(function IConst () G) +(let I (IConst)) +(function AConst () G) +(let A (AConst)) +(function BConst () G) +(let B (BConst)) + +(function g* (G G) G) +(function inv (G) G) +(birewrite (g* (g* a b) c) (g* a (g* b c))) ; assoc +(rewrite (g* I a) a) ; idl +(rewrite (g* a I) a) ; idr + +; A is cyclic of period 4 +(rewrite (g* A (g* A (g* A A))) I) + +(let A2 (g* A A)) +(let A4 (g* A2 A2)) +(let A8 (g* A4 A4)) + +; non terminating rule +(relation allgs (G)) +(rule ((allgs x)) ((allgs (g* B x)))) +(allgs A) + +; if you remove :until, this will take a very long time +(run 10000 :until (= A8 I)) +(check (= A8 I)) +(check (!= B A)) +(check (!= I A)) +; If you need multiple stop conditions, consider using a (relation relation stop (unit)) +; With rules filling it in with different stop conditions of interest. diff --git a/tests/vec.egg b/tests/vec.egg new file mode 100644 index 0000000..1202e41 --- /dev/null +++ b/tests/vec.egg @@ -0,0 +1,25 @@ +(sort IVec (Vec i64)) + +; Test vec-of +(check (= (vec-of 1 2) (vec-push (vec-push (vec-empty) 1) 2))) + +; Test vec-append +(check (= (vec-append (vec-of 1 2) (vec-of 3 4)) (vec-of 1 2 3 4))) + +; Test vec-pop +(check (= (vec-pop (vec-of 1 2 3)) (vec-of 1 2))) + +; Test vec-not-contains +(check (vec-not-contains (vec-of 1 2 3) 4)) + +; Test vec-contains +(check (vec-contains (vec-of 1 2 3) 2)) + +; Test length +(check (= (vec-length (vec-of 1 2 3)) 3)) + +; Test vec-get +(check (= (vec-get (vec-of 1 2 3) 1) 2)) + +; Test vec-set +(check (= (vec-set (vec-of 1 2 3) 1 4) (vec-of 1 4 3))) From 20bef0cbea44e0dcf128faaf7ec51b5fdf9b1381 Mon Sep 17 00:00:00 2001 From: Alex Fischman Date: Mon, 2 Dec 2024 14:58:06 -0800 Subject: [PATCH 04/10] Add Rational --- Cargo.lock | 3 +- Cargo.toml | 5 +- src/lib.rs | 14 +++++ src/main.rs | 2 +- src/rational.rs | 150 ++++++++++++++++++++++++++++++++++++++++++++++++ tests/files.rs | 15 ++--- 6 files changed, 179 insertions(+), 10 deletions(-) create mode 100644 src/rational.rs diff --git a/Cargo.lock b/Cargo.lock index 1519d1e..bbcab2c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -354,7 +354,6 @@ checksum = "675e35c02a51bb4d4618cb4885b3839ce6d1787c97b664474d9208d074742e20" [[package]] name = "egglog" version = "0.3.0" -source = "git+https://github.com/egraphs-good/egglog.git#86cb822cdff4481b9950126a70e21e70320814b0" dependencies = [ "chrono", "clap", @@ -384,7 +383,9 @@ dependencies = [ "codspeed-criterion-compat", "egglog", "glob", + "lazy_static", "libtest-mimic", + "num", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 336a981..40d8ccb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,7 +8,10 @@ harness = false name = "files" [dependencies] -egglog = { git = "https://github.com/egraphs-good/egglog.git" } +egglog = { path = "../egglog" } + +num = "0.4.3" +lazy_static = "1.4" [dev-dependencies] codspeed-criterion-compat = "2.7.2" diff --git a/src/lib.rs b/src/lib.rs index f8888fc..01f7f61 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1 +1,15 @@ pub use egglog::*; +use std::sync::Arc; + +mod rational; +pub use rational::*; + +pub struct EGraph(pub egglog::EGraph); + +impl Default for EGraph { + fn default() -> EGraph { + let mut inner = egglog::EGraph::default(); + inner.add_arcsort(Arc::new(RationalSort)).unwrap(); + EGraph(inner) + } +} diff --git a/src/main.rs b/src/main.rs index e7a11a9..c89b901 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,3 +1,3 @@ fn main() { - println!("Hello, world!"); + todo!(); } diff --git a/src/rational.rs b/src/rational.rs new file mode 100644 index 0000000..31ce391 --- /dev/null +++ b/src/rational.rs @@ -0,0 +1,150 @@ +use egglog::ast::{Expr, GenericExpr, Symbol, DUMMY_SPAN}; +use egglog::sort::{FromSort, IntoSort, Sort}; +use lazy_static::lazy_static; +use num::integer::Roots; +use num::rational::Rational64; +use num::traits::{CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, One, Signed, ToPrimitive, Zero}; +use std::any::Any; +use std::sync::{Arc, Mutex}; + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +struct R(Rational64); // orphan rule +use crate::{ast::Literal, util::IndexSet}; + +use super::*; + +lazy_static! { + static ref RATIONAL_SORT_NAME: Symbol = "Rational".into(); + static ref RATS: Mutex> = Default::default(); +} + +#[derive(Debug)] +pub struct RationalSort; + +impl Sort for RationalSort { + fn name(&self) -> Symbol { + *RATIONAL_SORT_NAME + } + + fn as_arc_any(self: Arc) -> Arc { + self + } + + #[rustfmt::skip] + fn register_primitives(self: Arc, eg: &mut TypeInfo) { + type Opt = Option; + + // TODO we can't have primitives take borrows just yet, since it + // requires returning a reference to the locked sort + add_primitives!(eg, "+" = |a: R, b: R| -> Opt { a.0.checked_add(&b.0).map(R) }); + add_primitives!(eg, "-" = |a: R, b: R| -> Opt { a.0.checked_sub(&b.0).map(R) }); + add_primitives!(eg, "*" = |a: R, b: R| -> Opt { a.0.checked_mul(&b.0).map(R) }); + add_primitives!(eg, "/" = |a: R, b: R| -> Opt { a.0.checked_div(&b.0).map(R) }); + + add_primitives!(eg, "min" = |a: R, b: R| -> R { R(a.0.min(b.0)) }); + add_primitives!(eg, "max" = |a: R, b: R| -> R { R(a.0.max(b.0)) }); + add_primitives!(eg, "neg" = |a: R| -> R { R(-a.0) }); + add_primitives!(eg, "abs" = |a: R| -> R { R(a.0.abs()) }); + add_primitives!(eg, "floor" = |a: R| -> R { R(a.0.floor()) }); + add_primitives!(eg, "ceil" = |a: R| -> R { R(a.0.ceil()) }); + add_primitives!(eg, "round" = |a: R| -> R { R(a.0.round()) }); + add_primitives!(eg, "rational" = |a: i64, b: i64| -> R { R(Rational64::new(a, b)) }); + add_primitives!(eg, "numer" = |a: R| -> i64 { *a.0.numer() }); + add_primitives!(eg, "denom" = |a: R| -> i64 { *a.0.denom() }); + + add_primitives!(eg, "to-f64" = |a: R| -> f64 { a.0.to_f64().unwrap() }); + + add_primitives!(eg, "pow" = |a: R, b: R| -> Option { + if a.0.is_zero() { + if b.0.is_positive() { + Some(R(Rational64::zero())) + } else { + None + } + } else if b.0.is_zero() { + Some(R(Rational64::one())) + } else if let Some(b) = b.0.to_i64() { + if let Ok(b) = usize::try_from(b) { + num::traits::checked_pow(a.0, b).map(R) + } else { + // TODO handle negative powers + None + } + } else { + None + } + }); + add_primitives!(eg, "log" = |a: R| -> Option { + if a.0.is_one() { + Some(R(Rational64::zero())) + } else { + todo!() + } + }); + add_primitives!(eg, "sqrt" = |a: R| -> Option { + if a.0.numer().is_positive() && a.0.denom().is_positive() { + let s1 = a.0.numer().sqrt(); + let s2 = a.0.denom().sqrt(); + let is_perfect = &(s1 * s1) == a.0.numer() && &(s2 * s2) == a.0.denom(); + if is_perfect { + Some(R(Rational64::new(s1, s2))) + } else { + None + } + } else { + None + } + }); + add_primitives!(eg, "cbrt" = |a: R| -> Option { + if a.0.is_one() { + Some(R(Rational64::one())) + } else { + todo!() + } + }); + + add_primitives!(eg, "<" = |a: R, b: R| -> Opt { if a.0 < b.0 {Some(())} else {None} }); + add_primitives!(eg, ">" = |a: R, b: R| -> Opt { if a.0 > b.0 {Some(())} else {None} }); + add_primitives!(eg, "<=" = |a: R, b: R| -> Opt { if a.0 <= b.0 {Some(())} else {None} }); + add_primitives!(eg, ">=" = |a: R, b: R| -> Opt { if a.0 >= b.0 {Some(())} else {None} }); + } + + fn make_expr(&self, _egraph: &egglog::EGraph, value: Value) -> (usize, Expr) { + #[cfg(debug_assertions)] + debug_assert_eq!(value.tag, self.name()); + + let rat = R::load(self, &value); + let numer = *rat.0.numer(); + let denom = *rat.0.denom(); + ( + 1, + Expr::call_no_span( + "rational", + vec![ + GenericExpr::Lit(DUMMY_SPAN.clone(), Literal::Int(numer)), + GenericExpr::Lit(DUMMY_SPAN.clone(), Literal::Int(denom)), + ], + ), + ) + } +} + +impl FromSort for R { + type Sort = RationalSort; + fn load(_sort: &Self::Sort, value: &Value) -> Self { + let i = value.bits as usize; + *RATS.lock().unwrap().get_index(i).unwrap() + } +} + +impl IntoSort for R { + type Sort = RationalSort; + fn store(self, _sort: &Self::Sort) -> Option { + let (i, _) = RATS.lock().unwrap().insert_full(self); + Some(Value { + #[cfg(debug_assertions)] + tag: RationalSort.name(), + bits: i as u64, + }) + } +} diff --git a/tests/files.rs b/tests/files.rs index 364c682..1402744 100644 --- a/tests/files.rs +++ b/tests/files.rs @@ -1,6 +1,6 @@ use std::path::PathBuf; -use egglog::*; +use egglog_experimental::*; use libtest_mimic::Trial; #[derive(Clone)] @@ -22,9 +22,10 @@ impl Run { ); } else { let mut egraph = EGraph::default(); - egraph.run_mode = RunMode::ShowDesugaredEgglog; - egraph.set_reserved_symbol("__".into()); + egraph.0.run_mode = RunMode::ShowDesugaredEgglog; + egraph.0.set_reserved_symbol("__".into()); let desugared_str = egraph + .0 .parse_and_run_program(self.path.to_str().map(String::from), &program) .unwrap() .join("\n"); @@ -39,8 +40,8 @@ impl Run { fn test_program(&self, filename: Option, program: &str, message: &str) { let mut egraph = EGraph::default(); - egraph.set_reserved_symbol("___".into()); - match egraph.parse_and_run_program(filename, program) { + egraph.0.set_reserved_symbol("___".into()); + match egraph.0.parse_and_run_program(filename, program) { Ok(msgs) => { if self.should_fail() { panic!( @@ -52,14 +53,14 @@ impl Run { println!(" {}", msg); } // Test graphviz dot generation - let mut serialized = egraph.serialize(SerializeConfig { + let mut serialized = egraph.0.serialize(SerializeConfig { max_functions: Some(40), max_calls_per_function: Some(40), ..Default::default() }); serialized.to_dot(); // Also try splitting and inlining - serialized.split_classes(|id, _| egraph.from_node_id(id).is_primitive()); + serialized.split_classes(|id, _| egraph.0.from_node_id(id).is_primitive()); serialized.inline_leaves(); serialized.to_dot(); } From 65d81d4fa072d4a27921ed092f4381ab5e159a42 Mon Sep 17 00:00:00 2001 From: Alex Fischman Date: Mon, 2 Dec 2024 15:01:03 -0800 Subject: [PATCH 05/10] Add Github CI script --- .github/CODEOWNERS | 1 + .github/workflows/build.yml | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+) create mode 100644 .github/CODEOWNERS create mode 100644 .github/workflows/build.yml diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..a0ed54b --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1 @@ +* @egraphs-good/egglog-reviewers \ No newline at end of file diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..3e4848b --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,35 @@ +name: Build + +on: [push, pull_request, workflow_dispatch] + +jobs: + test: + runs-on: ubuntu-latest + steps: + - run: echo "CARGO_INCREMENTAL=0" >> "$GITHUB_ENV" + - uses: actions/checkout@v3 + - uses: taiki-e/install-action@v2 + with: + tool: nextest + - uses: Swatinem/rust-cache@v2 + - run: make test + nits: + runs-on: ubuntu-latest + steps: + - run: echo "CARGO_INCREMENTAL=0" >> "$GITHUB_ENV" + - uses: actions/checkout@v3 + - uses: Swatinem/rust-cache@v2 + - run: make nits + benchmark: + runs-on: ubuntu-latest + steps: + - run: echo "CARGO_INCREMENTAL=0" >> "$GITHUB_ENV" + - uses: actions/checkout@v4 + - uses: taiki-e/install-action@v2 + with: + tool: cargo-codspeed + - uses: Swatinem/rust-cache@v2 + - run: cargo codspeed build + - uses: CodSpeedHQ/action@v3 + with: + run: cargo codspeed run From eb6b56c902b223c9a8ab8c3c9289382b0eb9bcb1 Mon Sep 17 00:00:00 2001 From: Alex Fischman Date: Mon, 2 Dec 2024 15:01:57 -0800 Subject: [PATCH 06/10] Remove benchmarks CI --- .github/workflows/build.yml | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 3e4848b..98caaec 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -20,16 +20,3 @@ jobs: - uses: actions/checkout@v3 - uses: Swatinem/rust-cache@v2 - run: make nits - benchmark: - runs-on: ubuntu-latest - steps: - - run: echo "CARGO_INCREMENTAL=0" >> "$GITHUB_ENV" - - uses: actions/checkout@v4 - - uses: taiki-e/install-action@v2 - with: - tool: cargo-codspeed - - uses: Swatinem/rust-cache@v2 - - run: cargo codspeed build - - uses: CodSpeedHQ/action@v3 - with: - run: cargo codspeed run From d5b7cbea9327dbb4b13aff642868e608733c6f70 Mon Sep 17 00:00:00 2001 From: Alex Fischman Date: Mon, 2 Dec 2024 15:06:41 -0800 Subject: [PATCH 07/10] Temp fix egglog dependency to test CI --- Cargo.lock | 1 + Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/Cargo.lock b/Cargo.lock index bbcab2c..41863b8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -354,6 +354,7 @@ checksum = "675e35c02a51bb4d4618cb4885b3839ce6d1787c97b664474d9208d074742e20" [[package]] name = "egglog" version = "0.3.0" +source = "git+https://github.com/Alex-Fischman/egglog.git?branch=remove-r64#555faf4cc5b48d0a3f87a553c7a0d60b1d610915" dependencies = [ "chrono", "clap", diff --git a/Cargo.toml b/Cargo.toml index 40d8ccb..d24b906 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,7 +8,7 @@ harness = false name = "files" [dependencies] -egglog = { path = "../egglog" } +egglog = { git = "https://github.com/Alex-Fischman/egglog.git", branch = "remove-r64" } num = "0.4.3" lazy_static = "1.4" From b61152aa3926b62e8a33a4cffe8a2878760929b0 Mon Sep 17 00:00:00 2001 From: Alex Fischman Date: Tue, 3 Dec 2024 14:36:10 -0800 Subject: [PATCH 08/10] Change wrapper+default to function --- src/lib.rs | 12 ++++-------- tests/files.rs | 17 ++++++++--------- 2 files changed, 12 insertions(+), 17 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 01f7f61..51363df 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -4,12 +4,8 @@ use std::sync::Arc; mod rational; pub use rational::*; -pub struct EGraph(pub egglog::EGraph); - -impl Default for EGraph { - fn default() -> EGraph { - let mut inner = egglog::EGraph::default(); - inner.add_arcsort(Arc::new(RationalSort)).unwrap(); - EGraph(inner) - } +pub fn new_experimental_egraph() -> EGraph { + let mut egraph = EGraph::default(); + egraph.add_arcsort(Arc::new(RationalSort)).unwrap(); + egraph } diff --git a/tests/files.rs b/tests/files.rs index 1402744..21daa0e 100644 --- a/tests/files.rs +++ b/tests/files.rs @@ -21,11 +21,10 @@ impl Run { "Top level error", ); } else { - let mut egraph = EGraph::default(); - egraph.0.run_mode = RunMode::ShowDesugaredEgglog; - egraph.0.set_reserved_symbol("__".into()); + let mut egraph = new_experimental_egraph(); + egraph.run_mode = RunMode::ShowDesugaredEgglog; + egraph.set_reserved_symbol("__".into()); let desugared_str = egraph - .0 .parse_and_run_program(self.path.to_str().map(String::from), &program) .unwrap() .join("\n"); @@ -39,9 +38,9 @@ impl Run { } fn test_program(&self, filename: Option, program: &str, message: &str) { - let mut egraph = EGraph::default(); - egraph.0.set_reserved_symbol("___".into()); - match egraph.0.parse_and_run_program(filename, program) { + let mut egraph = new_experimental_egraph(); + egraph.set_reserved_symbol("___".into()); + match egraph.parse_and_run_program(filename, program) { Ok(msgs) => { if self.should_fail() { panic!( @@ -53,14 +52,14 @@ impl Run { println!(" {}", msg); } // Test graphviz dot generation - let mut serialized = egraph.0.serialize(SerializeConfig { + let mut serialized = egraph.serialize(SerializeConfig { max_functions: Some(40), max_calls_per_function: Some(40), ..Default::default() }); serialized.to_dot(); // Also try splitting and inlining - serialized.split_classes(|id, _| egraph.0.from_node_id(id).is_primitive()); + serialized.split_classes(|id, _| egraph.from_node_id(id).is_primitive()); serialized.inline_leaves(); serialized.to_dot(); } From ea09b468cc3e76d54779b0e85a24ff423bac82c4 Mon Sep 17 00:00:00 2001 From: Alex Fischman Date: Tue, 3 Dec 2024 14:42:24 -0800 Subject: [PATCH 09/10] Delete unchanged tests --- tests/antiunify.egg | 26 - tests/array.egg | 77 - tests/bdd.egg | 107 - tests/bignum.egg | 13 - tests/birewrite.egg | 18 - tests/bitwise.egg | 37 - tests/bool.egg | 39 - tests/calc.egg | 61 - tests/combinators.egg | 102 - tests/combined-nested.egg | 48 - tests/container-rebuild.egg | 80 - tests/cyk.egg | 115 - tests/cykjson.egg | 44 - tests/cykjson_End.csv | 17 - tests/cykjson_Prod.csv | 17 - tests/cykjson_medium_token.csv | 7821 ----------------- tests/cykjson_small_token.csv | 801 -- tests/datatypes.egg | 11 - tests/delete.egg | 6 - tests/eggcc-extraction.egg | 1711 ---- tests/eqsat-basic-multiset.egg | 124 - tests/eqsat-basic.egg | 25 - tests/eqsolve.egg | 45 - tests/f64.egg | 13 - .../repro-containers-disallowed.egg | 4 - tests/fail-typecheck/repro-duplicated-var.egg | 3 - tests/fail-typecheck/unbound.egg | 6 - .../unstable-fn-wrong-args-type.egg | 8 - .../fail-typecheck/unstable-fn-wrong-args.egg | 8 - .../unstable-fn-wrong-return-type.egg | 8 - .../unstable-fn-wrong-return.egg | 11 - tests/fail_wrong_assertion.egg | 24 - tests/fibonacci-demand.egg | 19 - tests/fibonacci.egg | 11 - tests/fusion.egg | 152 - tests/i64.egg | 1 - tests/include.egg | 2 - tests/integer_math.egg | 106 - tests/integration_test.rs | 441 - tests/intersection.egg | 41 - tests/knapsack.egg | 46 - tests/lambda.egg | 242 - tests/levenshtein-distance.egg | 71 - tests/list.egg | 73 - tests/map.egg | 7 - tests/matrix.egg | 98 - tests/merge-during-rebuild.egg | 18 - tests/merge-saturates.egg | 24 - tests/multiset.egg | 58 - tests/name-resolution.egg | 25 - tests/path-union.egg | 21 - tests/path.egg | 19 - tests/pathproof.egg | 30 - tests/points-to.egg | 63 - tests/primitives.egg | 5 - tests/prims.egg | 124 - tests/push-pop.egg | 11 - tests/repro-define.egg | 9 - tests/repro-desugar-143.egg | 40 - tests/repro-empty-query.egg | 9 - tests/repro-equal-constant.egg | 9 - tests/repro-equal-constant2.egg | 9 - tests/repro-noteqbug.egg | 11 - tests/repro-primitive-query.egg | 12 - tests/repro-querybug.egg | 17 - tests/repro-querybug2.egg | 15 - tests/repro-querybug3.egg | 31 - tests/repro-querybug4.egg | 9 - tests/repro-should-saturate.egg | 10 - tests/repro-silly-panic.egg | 12 - tests/repro-typechecking-schedule.egg | 6 - tests/repro-vec-unequal.egg | 17 - tests/resolution.egg | 101 - tests/rw-analysis.egg | 284 - tests/schedule-demo.egg | 28 - tests/semi_naive_set_function.egg | 104 - tests/set.egg | 40 - tests/stratified.egg | 28 - tests/string.egg | 8 - tests/string_quotes.csv | 1 - tests/string_quotes.egg | 3 - tests/subsume.egg | 30 - tests/terms.rs | 33 - tests/test-combined-steps.egg | 53 - tests/test-combined.egg | 33 - tests/towers-of-hanoi.egg | 39 - tests/tricky-type-checking.egg | 138 - tests/type-constraints-tests.egg | 10 - tests/typecheck.egg | 102 - tests/typeinfer.egg | 337 - tests/unification-points-to.egg | 243 - tests/unify.egg | 26 - tests/unstable-fn.egg | 70 - tests/until.egg | 34 - tests/vec.egg | 25 - 95 files changed, 15124 deletions(-) delete mode 100644 tests/antiunify.egg delete mode 100644 tests/array.egg delete mode 100644 tests/bdd.egg delete mode 100644 tests/bignum.egg delete mode 100644 tests/birewrite.egg delete mode 100644 tests/bitwise.egg delete mode 100644 tests/bool.egg delete mode 100644 tests/calc.egg delete mode 100644 tests/combinators.egg delete mode 100644 tests/combined-nested.egg delete mode 100644 tests/container-rebuild.egg delete mode 100644 tests/cyk.egg delete mode 100644 tests/cykjson.egg delete mode 100644 tests/cykjson_End.csv delete mode 100644 tests/cykjson_Prod.csv delete mode 100644 tests/cykjson_medium_token.csv delete mode 100644 tests/cykjson_small_token.csv delete mode 100644 tests/datatypes.egg delete mode 100644 tests/delete.egg delete mode 100644 tests/eggcc-extraction.egg delete mode 100644 tests/eqsat-basic-multiset.egg delete mode 100644 tests/eqsat-basic.egg delete mode 100644 tests/eqsolve.egg delete mode 100644 tests/f64.egg delete mode 100644 tests/fail-typecheck/repro-containers-disallowed.egg delete mode 100644 tests/fail-typecheck/repro-duplicated-var.egg delete mode 100644 tests/fail-typecheck/unbound.egg delete mode 100644 tests/fail-typecheck/unstable-fn-wrong-args-type.egg delete mode 100644 tests/fail-typecheck/unstable-fn-wrong-args.egg delete mode 100644 tests/fail-typecheck/unstable-fn-wrong-return-type.egg delete mode 100644 tests/fail-typecheck/unstable-fn-wrong-return.egg delete mode 100644 tests/fail_wrong_assertion.egg delete mode 100644 tests/fibonacci-demand.egg delete mode 100644 tests/fibonacci.egg delete mode 100644 tests/fusion.egg delete mode 100644 tests/i64.egg delete mode 100644 tests/include.egg delete mode 100644 tests/integer_math.egg delete mode 100644 tests/integration_test.rs delete mode 100644 tests/intersection.egg delete mode 100644 tests/knapsack.egg delete mode 100644 tests/lambda.egg delete mode 100644 tests/levenshtein-distance.egg delete mode 100644 tests/list.egg delete mode 100644 tests/map.egg delete mode 100644 tests/matrix.egg delete mode 100644 tests/merge-during-rebuild.egg delete mode 100644 tests/merge-saturates.egg delete mode 100644 tests/multiset.egg delete mode 100644 tests/name-resolution.egg delete mode 100644 tests/path-union.egg delete mode 100644 tests/path.egg delete mode 100644 tests/pathproof.egg delete mode 100644 tests/points-to.egg delete mode 100644 tests/primitives.egg delete mode 100644 tests/prims.egg delete mode 100644 tests/push-pop.egg delete mode 100644 tests/repro-define.egg delete mode 100644 tests/repro-desugar-143.egg delete mode 100644 tests/repro-empty-query.egg delete mode 100644 tests/repro-equal-constant.egg delete mode 100644 tests/repro-equal-constant2.egg delete mode 100644 tests/repro-noteqbug.egg delete mode 100644 tests/repro-primitive-query.egg delete mode 100644 tests/repro-querybug.egg delete mode 100644 tests/repro-querybug2.egg delete mode 100644 tests/repro-querybug3.egg delete mode 100644 tests/repro-querybug4.egg delete mode 100644 tests/repro-should-saturate.egg delete mode 100644 tests/repro-silly-panic.egg delete mode 100644 tests/repro-typechecking-schedule.egg delete mode 100644 tests/repro-vec-unequal.egg delete mode 100644 tests/resolution.egg delete mode 100644 tests/rw-analysis.egg delete mode 100644 tests/schedule-demo.egg delete mode 100644 tests/semi_naive_set_function.egg delete mode 100644 tests/set.egg delete mode 100644 tests/stratified.egg delete mode 100644 tests/string.egg delete mode 100644 tests/string_quotes.csv delete mode 100644 tests/string_quotes.egg delete mode 100644 tests/subsume.egg delete mode 100644 tests/terms.rs delete mode 100644 tests/test-combined-steps.egg delete mode 100644 tests/test-combined.egg delete mode 100644 tests/towers-of-hanoi.egg delete mode 100644 tests/tricky-type-checking.egg delete mode 100644 tests/type-constraints-tests.egg delete mode 100644 tests/typecheck.egg delete mode 100644 tests/typeinfer.egg delete mode 100644 tests/unification-points-to.egg delete mode 100644 tests/unify.egg delete mode 100644 tests/unstable-fn.egg delete mode 100644 tests/until.egg delete mode 100644 tests/vec.egg diff --git a/tests/antiunify.egg b/tests/antiunify.egg deleted file mode 100644 index b9e5554..0000000 --- a/tests/antiunify.egg +++ /dev/null @@ -1,26 +0,0 @@ -(datatype Expr - (Num i64) - (Var String) - (Add Expr Expr)) - -(rewrite (Add x y) (Add y x)) -(rewrite (Add (Num x) (Num y)) (Num (+ x y))) - -;; antiunificaiton returns an expression that could unify with either -;; of the input expressions -;; (AU x y) can be considered a placeholder variable -(function AU (Expr Expr) Expr) - -(rewrite (AU x x) x) -(rewrite - (AU (Add a b) (Add c d)) - (Add (AU a c) (AU b d))) - -(let e1 (Add (Var "x") (Add (Num 1) (Num 2)))) -(let e2 (Add (Num 3) (Var "y"))) - -(let au12 (AU e1 e2)) - -(run 4) -(check (= au12 (Add (Num 3) (AU (Var "x") (Var "y"))))) -(query-extract au12) diff --git a/tests/array.egg b/tests/array.egg deleted file mode 100644 index f985aec..0000000 --- a/tests/array.egg +++ /dev/null @@ -1,77 +0,0 @@ -; Smtlib theory of arrays -; https://smtlib.cs.uiowa.edu/theories-ArraysEx.shtml -; http://smtlib.cs.uiowa.edu/version1/theories/Arrays.smt - -(datatype Math - (Num i64) - (Var String) -) - - -(datatype Array - (Const i64) - (AVar String) -) - -(function add (Math Math) Math) -(function select (Array Math) Math) -(function store (Array Math Math) Array) - -(relation neq (Math Math)) - -(rule ((neq x y)) - ((neq y x))) - -(rule ((neq x x)) - ((panic "query (neq x x) found something equal to itself"))) - - -; injectivity rules take not equal to not equal. -(rule ((neq x y) (= (add x z) e)) - ((neq (add x z) (add y z)))) -(rule ((= (add x (Num i)) e) (!= i 0)) - ((neq e x))) - - -(rule ((= (Num a) n1) (= (Num b) n2) (!= a b)) - ((neq n1 n2))) - -; select gets from store -(rewrite (select (store mem i e) i) e) -; select passes through wrong index -(rule ((= (select (store mem i1 e) i2) e1) (neq i1 i2)) - ((union (select mem i2) e1))) -; aliasing writes destroy old value -(rewrite (store (store mem i e1) i e2) (store mem i e2)) -; non-aliasing writes commutes -(rule ((= (store (store mem i2 e2) i1 e1) mem1) (neq i1 i2)) - ((union (store (store mem i1 e1) i2 e2) mem1))) - -; typical math rules -(rewrite (add x y) (add y x)) -(rewrite (add (add x y) z) (add x (add y z))) -(rewrite (add (Num x) (Num y)) (Num (+ x y))) -(rewrite (add x (Num 0)) x) - -(push) -(let r1 (Var "r1")) -(let r2 (Var "r2")) -(let r3 (Var "r3")) -(let mem1 (AVar "mem1")) - -(neq r1 r2) -(neq r2 r3) -(neq r1 r3) -(let test1 (select (store mem1 r1 (Num 42)) r1)) -(let test2 (select (store mem1 r1 (Num 42)) (add r1 (Num 17)))) -(let test3 (select (store (store mem1 (add r1 r2) (Num 1)) (add r2 r1) (Num 2)) (add r1 r3))) -(let test4 (add (Num 1) (add (add (Num 1) (add (Num 1) r1)) (Num -3)))) - -(run 5) -(check (= test1 (Num 42))) -(check (neq r1 r2)) -(check (neq r1 (add r1 (Num 17)))) -(check (= test2 (select mem1 (add r1 (Num 17))))) -(check (= test3 (select mem1 (add r1 r3)))) -(check (= test4 r1)) -(pop) diff --git a/tests/bdd.egg b/tests/bdd.egg deleted file mode 100644 index db10e51..0000000 --- a/tests/bdd.egg +++ /dev/null @@ -1,107 +0,0 @@ -; Binary Decision Diagrams are if-then-else trees/ compressed tries that hash cons their leaves -; This is easily expressible in the facilities provided. Everything in egglog is automatcally shared -; and Compression is easily expressible as a rule. - -; They are a notion of first class set useful for certain classes of uniformly describable sets. -; https://en.wikipedia.org/wiki/Binary_decision_diagram -; https://www.lri.fr/~filliatr/ftp/publis/hash-consing2.pdf Type-Safe Modular Hash-Consing - Section 3.3 - -(datatype BDD - (ITE i64 BDD BDD) ; variables labelled by number -) -(function TrueConst () BDD) -(let True (TrueConst)) -(function FalseConst () BDD) -(let False (FalseConst)) - -; compress unneeded nodes -(rewrite (ITE n a a) a) - -(function bddand (BDD BDD) BDD) -(rewrite (bddand x y) (bddand y x)) -(rewrite (bddand False n) False) -(rewrite (bddand True x) x) - -; We use an order where low variables are higher in tree -; Could go the other way. -(rewrite (bddand (ITE n a1 a2) (ITE m b1 b2)) - (ITE n (bddand a1 (ITE m b1 b2)) (bddand a2 (ITE m b1 b2))) - :when ((< n m)) -) -(rewrite (bddand (ITE n a1 a2) (ITE n b1 b2)) - (ITE n (bddand a1 b1) (bddand a2 b2)) -) - -(function bddor (BDD BDD) BDD) -(rewrite (bddor x y) (bddor y x)) -(rewrite (bddor True n) True) -(rewrite (bddor False x) x) -(rewrite (bddor (ITE n a1 a2) (ITE m b1 b2)) - (ITE n (bddor a1 (ITE m b1 b2)) (bddor a2 (ITE m b1 b2))) - :when ((< n m)) -) -(rewrite (bddor (ITE n a1 a2) (ITE n b1 b2)) - (ITE n (bddor a1 b1) (bddor a2 b2)) -) - -(function bddnot (BDD) BDD) -(rewrite (bddnot True) False) -(rewrite (bddnot False) True) -(rewrite (bddnot (ITE n a1 a2)) (ITE n (bddnot a1) (bddnot a2))) - - -(function bddxor (BDD BDD) BDD) -(rewrite (bddxor x y) (bddxor y x)) -(rewrite (bddxor True n) (bddnot n)) -(rewrite (bddxor False x) x) - -(rewrite (bddxor (ITE n a1 a2) (ITE m b1 b2)) - (ITE n (bddxor a1 (ITE m b1 b2)) (bddxor a2 (ITE m b1 b2))) - :when ((< n m)) -) -(rewrite (bddxor (ITE n a1 a2) (ITE n b1 b2)) - (ITE n (bddxor a1 b1) (bddxor a2 b2)) -) - -(push) -;;; Tests - -(let v0 (ITE 0 True False)) -(let v1 (ITE 1 True False)) -(let v2 (ITE 2 True False)) - -(let t0 (bddnot (bddnot v0))) -(let t1 (bddor v0 (bddnot v0))) -(let t2 (bddand v0 (bddnot v0))) -(let t3 (bddand v0 v0)) -(let t4 (bddor v0 v0)) -(let t5 (bddxor (bddnot v0) v0)) -(let t6 (bddand (bddor v1 v2) v2)) - -(let t7a (bddxor (bddnot v0) v1)) -(let t7b (bddxor v0 (bddnot v1))) -(let t7c (bddnot (bddxor v0 v1))) - -(let t8 (bddand v1 v2)) - -(let t9 (bddand (bddnot v1) (bddand (bddnot v0) (bddxor v0 v1)))) -(let t10 (bddor (bddnot v1) (bddor (bddnot v0) (bddxor v0 (bddnot v1))))) - -(run 30) - -(check (= t0 v0)) ; bddnot cancels -(check (= t1 True)) -(check (= t2 False)) -(check (= t3 v0)) -(check (= t4 v0)) -(check (= t5 True)) -(check (= t6 v2)) - -(check (= t7a t7b)) -(check (= t7a t7c)) - -(check (= t8 (ITE 1 (ITE 2 True False) False))) - -(check (= t9 False)) -(check (= t10 True)) -(pop) diff --git a/tests/bignum.egg b/tests/bignum.egg deleted file mode 100644 index 94c1732..0000000 --- a/tests/bignum.egg +++ /dev/null @@ -1,13 +0,0 @@ - -(let x (bigint -1234)) -(let y (from-string "2")) -(let z (bigrat x y)) -(check (= (to-string (numer z)) "-617")) - -(function bignums (BigInt BigInt) BigRat) -(set (bignums x y) z) -(check - (= (bignums a b) c) - (= (numer c) (>> a 1)) - (= (denom c) (>> b 1)) -) diff --git a/tests/birewrite.egg b/tests/birewrite.egg deleted file mode 100644 index a97bb63..0000000 --- a/tests/birewrite.egg +++ /dev/null @@ -1,18 +0,0 @@ -(datatype Math (Add Math Math) (Lit i64)) - -(birewrite (Add (Add x y) z) (Add x (Add y z))) - -(let a (Lit 1)) -(let b (Lit 2)) -(let c (Lit 3)) - -(let d (Lit 4)) -(let e (Lit 5)) -(let f (Lit 6)) - -(let ex1 (Add (Add a b) c)) -(let ex2 (Add d (Add e f))) - -(run 10) -(check (= ex1 (Add a (Add b c)))) -(check (= ex2 (Add (Add d e) f))) diff --git a/tests/bitwise.egg b/tests/bitwise.egg deleted file mode 100644 index e84fc1a..0000000 --- a/tests/bitwise.egg +++ /dev/null @@ -1,37 +0,0 @@ -(check (= 0 (& 10 0))) -(check (= 8 (& 8 10))) -(check (= 10 (| 8 10))) -(check (= 2 (^ 8 10))) -(check (= 8 (<< 1 3))) -(check (= 1 (>> 8 3))) -(check (= 2 (% 8 3))) -(check (= 2 (/ 8 3))) -(check (= -1 (not-i64 0))) - -; bitsets -;(function bs-union (i64 i64) i64) -;(rewrite (bs-union a b) (| a b)) - -;(function bs-inter (i64 i64) i64) -;(rewrite (bs-inter a b) (& a b)) - -;(function bs-comp (i64) i64) -;(rewrite (bs-comp a) (bvnot a)) - -; singleton set -;(function bs-sing (i64) i64) -;(rewrite (bs-sing a) (1 << a)) - -;(function bs-insert (i64 i64) i64) -;(rewrite (bs-insert s x) (| s (1 << a)) - -;(function bs-diff (i64 i64) i64) -;(rewrite (bs-diff a b) (^ a (bs-inter a b)) - -;(let bs-empty 0) - -;(let bs-subset (i64 i64) bool) -;(rewrite (bs-subset x y) (is-zero (bs-diff x y))) - -;(let bs-is-elem (i64 i64) bool) -;(rewrite (bs-is-elem s x) (not (is-zero (bs-inter s (sing x))))) diff --git a/tests/bool.egg b/tests/bool.egg deleted file mode 100644 index 721e2c9..0000000 --- a/tests/bool.egg +++ /dev/null @@ -1,39 +0,0 @@ - -(check (= (and true true) true)) -(check (= (and true false) false)) -(check (= (or true false) true)) -(check (!= (or true false) false)) - -(check (= (bool-= 1 1) true)) -(check (= (bool-= -5 -5) true)) -(check (= (bool-= 1 3) false)) -(check (= (bool-= 3 1) false)) - -(check (= (bool-< 1 2) true)) -(check (= (bool-< 2 1) false)) -(check (= (bool-< 1 1) false)) - -(check (= (bool-<= 1 2) true)) -(check (= (bool-<= 2 1) false)) -(check (= (bool-<= 1 1) true)) - -(check (= (bool-> 1 2) false)) -(check (= (bool-> 2 1) true)) -(check (= (bool-> 1 1) false)) - -(check (= (bool->= 1 2) false)) -(check (= (bool->= 2 1) true)) -(check (= (bool->= 1 1) true)) - -; Test bool's tag -(relation R (i64)) -(function F (i64) bool) - -(rule - ((R i)) - ((set (F i) true)) -) - -(R 0) - -(run 3) diff --git a/tests/calc.egg b/tests/calc.egg deleted file mode 100644 index f53cb81..0000000 --- a/tests/calc.egg +++ /dev/null @@ -1,61 +0,0 @@ -(datatype G) -(function IConst () G) -(let I (IConst)) -(function AConst () G) -(let A (AConst)) -(function BConst () G) -(let B (BConst)) -(function g* (G G) G) -(function inv (G) G) -(birewrite (g* (g* a b) c) (g* a (g* b c))) ; assoc -(rewrite (g* I a) a) ; idl -(rewrite (g* a I) a) ; idr -(rewrite (g* (inv a) a) I) ; invl -(rewrite (g* a (inv a)) I) ; invr - -; A is cyclic of period 4 -(rewrite (g* A (g* A (g* A A))) I) - -(let A2 (g* A A)) -(let A4 (g* A2 A2)) -(let A8 (g* A4 A4)) - - -(push) -(g* A4 A4) - -(run 10000 :until (= (g* A4 A4) (g* (g* A2 A2) (g* A2 A2)))) - -(check (= (g* A4 A4) (g* (g* A2 A2) (g* A2 A2)))) -(pop) - -(push) -(g* (g* A2 A2) (g* A2 A2)) - -(run 10000 :until (= (g* (g* A2 A2) (g* A2 A2)) -(g* A2 (g* A2 (g* A2 A2))))) -(check (= (g* (g* A2 A2) (g* A2 A2)) -(g* A2 (g* A2 (g* A2 A2))))) -(pop) - - -(function aConst () G) -(function bConst () G) -(let a (aConst)) -(let b (bConst)) -(push) - -(g* (g* b (g* (inv a) a)) (inv b)) - -(run 100000 :until (= (g* (g* b (g* (inv a) a)) (inv b)) (g* b (inv b)))) - -(check (= (g* (g* b (g* (inv a) a)) (inv b)) (g* b (inv b)))) - -(pop) - -(push) -(g* b (inv b)) -(run 100000 :until (= (g* b (inv b)) I)) -(check (= (g* b (inv b)) I)) - -(pop) diff --git a/tests/combinators.egg b/tests/combinators.egg deleted file mode 100644 index 8bf57d9..0000000 --- a/tests/combinators.egg +++ /dev/null @@ -1,102 +0,0 @@ -; Substitution in lambda-calculus via S/K/I combinators. Extremely slow, as -; abstraction elimination does not pay attention to whether variables are free -; in an expression before introducing 'S'. -; -; Provides an example of how to implement substitution by embedding in a -; 'richer' data-type and then mapping back to syntax. - -(datatype Expr - (Var String :cost 100) - (Abs String Expr) - (If Expr Expr Expr) - (N i64) - (Add Expr Expr) - (App Expr Expr)) -(function TConst () Expr) -(let T (TConst)) -(function FConst () Expr) -(let F (FConst)) - - -; (\x. (if x then 0 else 1) + 2) false -(let test - (App - (Abs "x" (Add (If (Var "x") (N 0) (N 1)) (N 2))) F)) - -(datatype CExpr - (CVar String :cost 10000) ; (variables that haven't been eliminated yet) - (CAbs String CExpr :cost 10000) ; (abstractions that haven't been eliminated yet) - (CN i64) - (CApp CExpr CExpr)) -(function CTConst () CExpr) -(let CT (CTConst)) -(function CFConst () CExpr) -(let CF (CFConst)) -(function CIfConst () CExpr) -(let CIf (CIfConst)) -(function CAddConst () CExpr) -(let CAdd (CAddConst)) -(function SConst () CExpr) -(let S (SConst)) -(function KConst () CExpr) -(let K (KConst)) -(function IConst () CExpr) -(let I (IConst)) - -;;;; Conversion functions -(function Comb (Expr) CExpr :cost 1000000) -(function Uncomb (CExpr) Expr) -(rewrite (Comb (Uncomb cx)) cx) -(rewrite (Uncomb (Comb x)) x) - -; Mechanical mappings back and forth. -; Note: we avoid resugaring S/K/I -(rule ((= x (N n))) ((union (Comb x) (CN n)))) -(rule ((= cx (CN n))) ((union (Uncomb cx) (N n)))) -(rule ((= x T)) ((union (Comb x) CT))) -(rule ((= cx CT)) ((union (Uncomb cx) T))) -(rule ((= x F)) ((union (Comb x) CF))) -(rule ((= cx CF)) ((union (Uncomb cx) F))) - -(rule ((= x (If c t f))) - ((union (Comb x) (CApp (CApp (CApp CIf (Comb c)) (Comb t)) (Comb f))))) -(rule ((= cx (CApp (CApp (CApp CIf cc) ct) cf))) - ((union (Uncomb cx) (If (Uncomb cc) (Uncomb ct) (Uncomb cf))))) - -(rule ((= x (Add l r))) - ((union (Comb x) (CApp (CApp CAdd (Comb l)) (Comb r))))) -(rule ((= cx (CApp (CApp CAdd cl) cr))) - ((union (Uncomb cx) (Add (Uncomb cl) (Uncomb cr))))) -(rule ((= x (App f a))) ((union (Comb x) (CApp (Comb f) (Comb a))))) - -(rule ((= x (Var v))) ((union (Comb x) (CVar v)))) -(rule ((= x (Abs v body))) ((union (Comb x) (CAbs v (Comb body))))) - -;;;; Abstraction Elimination -(rewrite (CAbs v (CVar v)) I) -; Hacks, could be replaced by !free computation. -(rewrite (CAbs v1 (CVar v2)) (CApp K (CVar v2)) - :when ((!= v1 v2))) -(rewrite (CAbs v (CN n)) (CApp K (CN n))) -(rewrite (CAbs v CT) (CApp K CT)) -(rewrite (CAbs v CF) (CApp K CF)) -(rewrite (CAbs v CIf) (CApp K CIf)) -(rewrite (CAbs v CAdd) (CApp K CAdd)) -(rewrite (CAbs v (CApp x y)) (CApp (CApp S (CAbs v x)) (CAbs v y))) -; May be needed for multiple nested variables -(rewrite (CAbs v (CApp K (CVar v))) K) - -;;;; Primitive Evaluation rules (letd on "surface syntax") -(rewrite (If T t f) t) -(rewrite (If F t f) f) -(rewrite (Add (N n) (N m)) (N (+ n m))) - -;;;; Substitution Rules (letd on the combinator representation) -(rewrite (CApp I cx) cx) -(rewrite (CApp (CApp K cx) cy) cx) -; Without demand, this can cause an explosion in DB size. -(rewrite (CApp (CApp (CApp S cx) cy) cz) (CApp (CApp cx cz) (CApp cy cz))) - -(run 11) -(query-extract (Comb test)) -(check (= test (N 3))) \ No newline at end of file diff --git a/tests/combined-nested.egg b/tests/combined-nested.egg deleted file mode 100644 index e0d7af3..0000000 --- a/tests/combined-nested.egg +++ /dev/null @@ -1,48 +0,0 @@ -(relation number (i64)) - - -(ruleset myrules1) -(rule () - ((number 1)) - :ruleset myrules1) -(ruleset myrules2) -(rule () - ((number 2)) - :ruleset myrules2) - -(unstable-combined-ruleset rules1and2 - myrules1 myrules2) - -;; allowed to add to myrules2 and the change is reflected -(rule () - ((number 3)) - :ruleset myrules2) - -;; not allowed to add to combined ruleset -(fail - (rule () - ((number 4)) - :ruleset myrules1and2)) - - -(fail - (rule () - ((number 4)) - :ruleset unboundruleset)) - -(ruleset myrules5) -(rule () - ((number 5)) - :ruleset myrules5) - -(unstable-combined-ruleset rules1and2and5 - rules1and2 myrules5) - -(run-schedule - rules1and2and5) - -(check (number 1)) -(check (number 2)) -(check (number 3)) -(check (number 5)) -(fail (check (number 4))) diff --git a/tests/container-rebuild.egg b/tests/container-rebuild.egg deleted file mode 100644 index 3394a00..0000000 --- a/tests/container-rebuild.egg +++ /dev/null @@ -1,80 +0,0 @@ -(push) -(datatype Math - (Num i64)) - -(sort MathVec (Vec Math)) - -(let v1 (vec-of (Num 1) (Num 2))) -(let v2 (vec-of (Num 2) (Num 2))) - -(union (Num 1) (Num 2)) - -(check (= v1 v2)) - -(function MyVec (MathVec) Math) - -(MyVec v1) - -(check (MyVec v2)) - -(check (= (MyVec v1) (MyVec v2))) - -(let v3 (vec-of (Num 4) (Num 5))) - -(union (Num 4) (Num 6)) -(union (Num 5) (Num 7)) - -;; We don't have any (MyVec v3) yet -(fail (check (= (MyVec v3) (MyVec (vec-of (Num 6) (Num 7)))))) - -(MyVec v3) -(check (= (MyVec v3) (MyVec (vec-of (Num 6) (Num 7))))) - -(pop) - -(push) - -(datatype Math - (Num i64)) - -(sort MathVec (Vec Math)) - - -(let v1 (vec-of (Num 1) (Num 2))) -(let v2 (vec-of (Num 2) (Num 2))) - -(union (Num 1) (Num 2)) - -(function MyVec (MathVec) Math) - -;; make a reference to v1 -(MyVec v1) - -(extract (MyVec v1)) - -;; rebuilding creates (MyVec v2) -(check (= (MyVec v1) (MyVec v2))) -(pop) - -(push) -(datatype Math - (Add i64 i64) - (Expensive :cost 100)) - -(sort MathVec (Vec Math)) - -(let myvec (vec-of (Expensive))) -(let cheapvec (vec-of (Add 1 2))) - -(function VecContainer (MathVec) Math) - -(let myvecontainer (VecContainer cheapvec)) - - -(union myvecontainer (Expensive)) - -;; (vec-push (vec-empty) (VecContainer (vec-push (vec-empty) (Add 1 2)))) -;; should have cost 4 -(extract myvec 0) - -(pop) \ No newline at end of file diff --git a/tests/cyk.egg b/tests/cyk.egg deleted file mode 100644 index 9bd0ef9..0000000 --- a/tests/cyk.egg +++ /dev/null @@ -1,115 +0,0 @@ -(datatype term (Term String)) -(datatype nonterm (NonTerm String)) -(datatype tree (NT String tree tree) - (T String String)) - -(function getString (i64) String) - -(relation Prod (nonterm nonterm nonterm)) -(relation End (nonterm String)) - - - -(relation P (i64 i64 nonterm)) -(function B (i64 i64 nonterm) tree :cost 1000) - -(rule ((End (NonTerm a) s) - (= s (getString pos))) - ((P 1 pos (NonTerm a)) - (union (B 1 pos (NonTerm a)) (T a s)))) - -(rule ((Prod (NonTerm a) (NonTerm b) (NonTerm c)) ;; a -> bc - (P p1 s (NonTerm b)) - (P p2 (+ s p1) (NonTerm c))) - ((P (+ p1 p2) s (NonTerm a)))) - - -(rule ((Prod (NonTerm a) (NonTerm b) (NonTerm c)) - (= f1 (B p1 s (NonTerm b))) - (= f2 (B p2 (+ s p1) (NonTerm c)))) - ((union (B (+ p1 p2) s (NonTerm a)) - (NT a f1 f2)))) - -(push) - - -(set (getString 1) "she") -(set (getString 2) "eats") -(set (getString 3) "a") -(set (getString 4) "fish") -(set (getString 5) "with") -(set (getString 6) "a") -(set (getString 7) "fork") - - -(Prod (NonTerm "S") (NonTerm "NP") (NonTerm "VP")) -(Prod (NonTerm "VP") (NonTerm "VP") (NonTerm "PP")) -(Prod (NonTerm "VP") (NonTerm "V") (NonTerm "NP")) -(End (NonTerm "VP") "eats") -(Prod (NonTerm "PP") (NonTerm "P") (NonTerm "NP")) -(Prod (NonTerm "NP") (NonTerm "DET") (NonTerm "N")) -(End (NonTerm "NP") "she") -(End (NonTerm "V") "eats") -(End (NonTerm "P") "with") -(End (NonTerm "N") "fish") -(End (NonTerm "N") "fork") -(End (NonTerm "DET") "a") - - -(let test1 (B 7 1 (NonTerm "S"))) - -(run 100) - -(check (P 7 1 (NonTerm "S"))) -(fail (check (P 7 1 (NonTerm "VP")))) -(fail (check (P 7 1 (NonTerm "")))) - -(query-extract test1) - -(pop) - -(push) - -(Prod (NonTerm "S") (NonTerm "A") (NonTerm "B")) -(Prod (NonTerm "S") (NonTerm "B") (NonTerm "C")) -(Prod (NonTerm "A") (NonTerm "B") (NonTerm "A")) -(End (NonTerm "A") "a") -(Prod (NonTerm "B") (NonTerm "C") (NonTerm "C")) -(End (NonTerm "B") "b") -(Prod (NonTerm "C") (NonTerm "A") (NonTerm "B")) -(End (NonTerm "C") "a") - -(push) - -(set (getString 1) "a") -(set (getString 2) "b") -(set (getString 3) "a") -(set (getString 4) "a") -(set (getString 5) "b") - -(run 100) -(check (P 5 1 (NonTerm "S"))) -(fail (check (P 5 1 (NonTerm "B")))) -(let test2 (B 5 1 (NonTerm "S"))) -(query-extract:variants 10 test2) - -(pop) - -(push) - -(set (getString 1) "a") -(set (getString 2) "a") -(set (getString 3) "a") -(set (getString 4) "a") -(set (getString 5) "a") - -(run 100) -(check (P 5 1 (NonTerm "S"))) -(check (P 5 1 (NonTerm "A"))) -(fail (check (P 5 1 (NonTerm "B")))) -(fail (check (P 5 1 (NonTerm "")))) -(fail (check (P 5 1 (NonTerm "unrelated")))) -(let test3 (B 5 1 (NonTerm "S"))) -(query-extract :variants 10 test3) - -(pop) \ No newline at end of file diff --git a/tests/cykjson.egg b/tests/cykjson.egg deleted file mode 100644 index 3c595df..0000000 --- a/tests/cykjson.egg +++ /dev/null @@ -1,44 +0,0 @@ -(datatype tree (NT String tree tree) - (T String String)) - -(function getString (i64) String) - -(relation Prod (String String String)) -(relation End (String String)) - - -(relation P (i64 i64 String)) -(function B (i64 i64 String) tree :cost 100000) - -(rule ((End a s) - (= s (getString pos))) - ((P 1 pos a) - (union (B 1 pos a) (T a s)))) - -(rule ((Prod a b c) ;; a -> bc - (P p1 s b) - (P p2 (+ s p1) c)) - ((P (+ p1 p2) s a))) - - -(rule ((Prod a b c) - (= f1 (B p1 s b)) - (= f2 (B p2 (+ s p1) c))) - ((union (B (+ p1 p2) s a) - (NT a f1 f2)))) - - -(input Prod "./tests/cykjson_Prod.csv") -(input End "./tests/cykjson_End.csv") - -; small size 801 -(input getString "./tests/cykjson_small_token.csv") - -; medium size 7821 but runs for 2 min. -;(input getString "./tests/cykjson_medium_token.csv") - -(let test1 (B 801 1 "VAL")) - -(run 10000) - -(check (P 801 1 "VAL")) \ No newline at end of file diff --git a/tests/cykjson_End.csv b/tests/cykjson_End.csv deleted file mode 100644 index 5df5616..0000000 --- a/tests/cykjson_End.csv +++ /dev/null @@ -1,17 +0,0 @@ -VAL str -VAL num -VAL true -VAL false -VAL null -ELM str -ELM num -ELM true -ELM false -ELM null -H0 { -H1 } -H3 [ -H4 ] -H9 , -H10 str -H11 : \ No newline at end of file diff --git a/tests/cykjson_Prod.csv b/tests/cykjson_Prod.csv deleted file mode 100644 index ba4adac..0000000 --- a/tests/cykjson_Prod.csv +++ /dev/null @@ -1,17 +0,0 @@ -VAL H0 H1 -VAL H2 H1 -VAL H3 H4 -VAL H5 H4 -MEM H6 MEM -MEM H7 VAL -PR H7 VAL -ELM H8 ELM -ELM H0 H1 -ELM H2 H1 -ELM H3 H4 -ELM H5 H4 -H2 H0 MEM -H5 H3 ELM -H6 PR H9 -H7 H10 H11 -H8 VAL H9 \ No newline at end of file diff --git a/tests/cykjson_medium_token.csv b/tests/cykjson_medium_token.csv deleted file mode 100644 index 6bb3a3e..0000000 --- a/tests/cykjson_medium_token.csv +++ /dev/null @@ -1,7821 +0,0 @@ -1 { -2 str -3 : -4 [ -5 { -6 str -7 : -8 str -9 , -10 str -11 : -12 { -13 str -14 : -15 str -16 , -17 str -18 : -19 num -20 , -21 str -22 : -23 { -24 str -25 : -26 num -27 , -28 str -29 : -30 num -31 } -32 , -33 str -34 : -35 str -36 , -37 str -38 : -39 num -40 , -41 str -42 : -43 { -44 str -45 : -46 num -47 , -48 str -49 : -50 str -51 , -52 str -53 : -54 str -55 , -56 str -57 : -58 str -59 , -60 str -61 : -62 str -63 , -64 str -65 : -66 str -67 } -68 , -69 str -70 : -71 { -72 str -73 : -74 str -75 , -76 str -77 : -78 str -79 } -80 } -81 } -82 , -83 { -84 str -85 : -86 str -87 , -88 str -89 : -90 { -91 str -92 : -93 str -94 , -95 str -96 : -97 num -98 , -99 str -100 : -101 { -102 str -103 : -104 num -105 , -106 str -107 : -108 num -109 } -110 , -111 str -112 : -113 str -114 , -115 str -116 : -117 num -118 , -119 str -120 : -121 { -122 str -123 : -124 num -125 , -126 str -127 : -128 str -129 , -130 str -131 : -132 str -133 , -134 str -135 : -136 str -137 , -138 str -139 : -140 str -141 , -142 str -143 : -144 str -145 } -146 , -147 str -148 : -149 { -150 str -151 : -152 str -153 , -154 str -155 : -156 str -157 } -158 } -159 } -160 , -161 { -162 str -163 : -164 str -165 , -166 str -167 : -168 { -169 str -170 : -171 str -172 , -173 str -174 : -175 num -176 , -177 str -178 : -179 { -180 str -181 : -182 num -183 , -184 str -185 : -186 num -187 } -188 , -189 str -190 : -191 str -192 , -193 str -194 : -195 num -196 , -197 str -198 : -199 { -200 str -201 : -202 num -203 , -204 str -205 : -206 str -207 , -208 str -209 : -210 str -211 , -212 str -213 : -214 str -215 , -216 str -217 : -218 str -219 , -220 str -221 : -222 str -223 } -224 , -225 str -226 : -227 { -228 str -229 : -230 str -231 , -232 str -233 : -234 str -235 } -236 } -237 } -238 , -239 { -240 str -241 : -242 str -243 , -244 str -245 : -246 { -247 str -248 : -249 str -250 , -251 str -252 : -253 num -254 , -255 str -256 : -257 { -258 str -259 : -260 num -261 , -262 str -263 : -264 num -265 } -266 , -267 str -268 : -269 str -270 , -271 str -272 : -273 num -274 , -275 str -276 : -277 { -278 str -279 : -280 num -281 , -282 str -283 : -284 str -285 , -286 str -287 : -288 str -289 , -290 str -291 : -292 str -293 , -294 str -295 : -296 str -297 , -298 str -299 : -300 str -301 } -302 , -303 str -304 : -305 { -306 str -307 : -308 str -309 , -310 str -311 : -312 str -313 } -314 } -315 } -316 , -317 { -318 str -319 : -320 str -321 , -322 str -323 : -324 { -325 str -326 : -327 str -328 , -329 str -330 : -331 num -332 , -333 str -334 : -335 { -336 str -337 : -338 num -339 , -340 str -341 : -342 num -343 } -344 , -345 str -346 : -347 str -348 , -349 str -350 : -351 num -352 , -353 str -354 : -355 { -356 str -357 : -358 num -359 , -360 str -361 : -362 str -363 , -364 str -365 : -366 str -367 , -368 str -369 : -370 str -371 , -372 str -373 : -374 str -375 , -376 str -377 : -378 str -379 } -380 , -381 str -382 : -383 { -384 str -385 : -386 str -387 , -388 str -389 : -390 str -391 } -392 } -393 } -394 , -395 { -396 str -397 : -398 str -399 , -400 str -401 : -402 { -403 str -404 : -405 str -406 , -407 str -408 : -409 num -410 , -411 str -412 : -413 { -414 str -415 : -416 num -417 , -418 str -419 : -420 num -421 } -422 , -423 str -424 : -425 str -426 , -427 str -428 : -429 num -430 , -431 str -432 : -433 { -434 str -435 : -436 num -437 , -438 str -439 : -440 str -441 , -442 str -443 : -444 str -445 , -446 str -447 : -448 str -449 , -450 str -451 : -452 str -453 , -454 str -455 : -456 str -457 } -458 , -459 str -460 : -461 { -462 str -463 : -464 str -465 , -466 str -467 : -468 str -469 } -470 } -471 } -472 , -473 { -474 str -475 : -476 str -477 , -478 str -479 : -480 { -481 str -482 : -483 str -484 , -485 str -486 : -487 num -488 , -489 str -490 : -491 { -492 str -493 : -494 num -495 , -496 str -497 : -498 num -499 } -500 , -501 str -502 : -503 str -504 , -505 str -506 : -507 num -508 , -509 str -510 : -511 { -512 str -513 : -514 num -515 , -516 str -517 : -518 str -519 , -520 str -521 : -522 str -523 , -524 str -525 : -526 str -527 , -528 str -529 : -530 str -531 , -532 str -533 : -534 str -535 } -536 , -537 str -538 : -539 { -540 str -541 : -542 str -543 , -544 str -545 : -546 str -547 } -548 } -549 } -550 , -551 { -552 str -553 : -554 str -555 , -556 str -557 : -558 { -559 str -560 : -561 str -562 , -563 str -564 : -565 num -566 , -567 str -568 : -569 { -570 str -571 : -572 num -573 , -574 str -575 : -576 num -577 } -578 , -579 str -580 : -581 str -582 , -583 str -584 : -585 num -586 , -587 str -588 : -589 { -590 str -591 : -592 num -593 , -594 str -595 : -596 str -597 , -598 str -599 : -600 str -601 , -602 str -603 : -604 str -605 , -606 str -607 : -608 str -609 , -610 str -611 : -612 str -613 } -614 , -615 str -616 : -617 { -618 str -619 : -620 str -621 , -622 str -623 : -624 str -625 } -626 } -627 } -628 , -629 { -630 str -631 : -632 str -633 , -634 str -635 : -636 { -637 str -638 : -639 str -640 , -641 str -642 : -643 num -644 , -645 str -646 : -647 { -648 str -649 : -650 num -651 , -652 str -653 : -654 num -655 } -656 , -657 str -658 : -659 str -660 , -661 str -662 : -663 num -664 , -665 str -666 : -667 { -668 str -669 : -670 num -671 , -672 str -673 : -674 str -675 , -676 str -677 : -678 str -679 , -680 str -681 : -682 str -683 , -684 str -685 : -686 str -687 , -688 str -689 : -690 str -691 } -692 , -693 str -694 : -695 { -696 str -697 : -698 str -699 , -700 str -701 : -702 str -703 } -704 } -705 } -706 , -707 { -708 str -709 : -710 str -711 , -712 str -713 : -714 { -715 str -716 : -717 str -718 , -719 str -720 : -721 num -722 , -723 str -724 : -725 { -726 str -727 : -728 num -729 , -730 str -731 : -732 num -733 } -734 , -735 str -736 : -737 str -738 , -739 str -740 : -741 num -742 , -743 str -744 : -745 { -746 str -747 : -748 num -749 , -750 str -751 : -752 str -753 , -754 str -755 : -756 str -757 , -758 str -759 : -760 str -761 , -762 str -763 : -764 str -765 , -766 str -767 : -768 str -769 } -770 , -771 str -772 : -773 { -774 str -775 : -776 str -777 , -778 str -779 : -780 str -781 } -782 } -783 } -784 , -785 { -786 str -787 : -788 str -789 , -790 str -791 : -792 { -793 str -794 : -795 str -796 , -797 str -798 : -799 num -800 , -801 str -802 : -803 { -804 str -805 : -806 num -807 , -808 str -809 : -810 num -811 } -812 , -813 str -814 : -815 str -816 , -817 str -818 : -819 num -820 , -821 str -822 : -823 { -824 str -825 : -826 num -827 , -828 str -829 : -830 str -831 , -832 str -833 : -834 str -835 , -836 str -837 : -838 str -839 , -840 str -841 : -842 str -843 , -844 str -845 : -846 str -847 } -848 , -849 str -850 : -851 { -852 str -853 : -854 str -855 , -856 str -857 : -858 str -859 } -860 } -861 } -862 , -863 { -864 str -865 : -866 str -867 , -868 str -869 : -870 { -871 str -872 : -873 str -874 , -875 str -876 : -877 num -878 , -879 str -880 : -881 { -882 str -883 : -884 num -885 , -886 str -887 : -888 num -889 } -890 , -891 str -892 : -893 str -894 , -895 str -896 : -897 num -898 , -899 str -900 : -901 { -902 str -903 : -904 num -905 , -906 str -907 : -908 str -909 , -910 str -911 : -912 str -913 , -914 str -915 : -916 str -917 , -918 str -919 : -920 str -921 , -922 str -923 : -924 str -925 } -926 , -927 str -928 : -929 { -930 str -931 : -932 str -933 , -934 str -935 : -936 str -937 } -938 } -939 } -940 , -941 { -942 str -943 : -944 str -945 , -946 str -947 : -948 { -949 str -950 : -951 str -952 , -953 str -954 : -955 num -956 , -957 str -958 : -959 { -960 str -961 : -962 num -963 , -964 str -965 : -966 num -967 } -968 , -969 str -970 : -971 str -972 , -973 str -974 : -975 num -976 , -977 str -978 : -979 { -980 str -981 : -982 num -983 , -984 str -985 : -986 str -987 , -988 str -989 : -990 str -991 , -992 str -993 : -994 str -995 , -996 str -997 : -998 str -999 , -1000 str -1001 : -1002 str -1003 } -1004 , -1005 str -1006 : -1007 { -1008 str -1009 : -1010 str -1011 , -1012 str -1013 : -1014 str -1015 } -1016 } -1017 } -1018 , -1019 { -1020 str -1021 : -1022 str -1023 , -1024 str -1025 : -1026 { -1027 str -1028 : -1029 str -1030 , -1031 str -1032 : -1033 num -1034 , -1035 str -1036 : -1037 { -1038 str -1039 : -1040 num -1041 , -1042 str -1043 : -1044 num -1045 } -1046 , -1047 str -1048 : -1049 str -1050 , -1051 str -1052 : -1053 num -1054 , -1055 str -1056 : -1057 { -1058 str -1059 : -1060 num -1061 , -1062 str -1063 : -1064 str -1065 , -1066 str -1067 : -1068 str -1069 , -1070 str -1071 : -1072 str -1073 , -1074 str -1075 : -1076 str -1077 , -1078 str -1079 : -1080 str -1081 } -1082 , -1083 str -1084 : -1085 { -1086 str -1087 : -1088 str -1089 , -1090 str -1091 : -1092 str -1093 } -1094 } -1095 } -1096 , -1097 { -1098 str -1099 : -1100 str -1101 , -1102 str -1103 : -1104 { -1105 str -1106 : -1107 str -1108 , -1109 str -1110 : -1111 num -1112 , -1113 str -1114 : -1115 { -1116 str -1117 : -1118 num -1119 , -1120 str -1121 : -1122 num -1123 } -1124 , -1125 str -1126 : -1127 str -1128 , -1129 str -1130 : -1131 num -1132 , -1133 str -1134 : -1135 { -1136 str -1137 : -1138 num -1139 , -1140 str -1141 : -1142 str -1143 , -1144 str -1145 : -1146 str -1147 , -1148 str -1149 : -1150 str -1151 , -1152 str -1153 : -1154 str -1155 , -1156 str -1157 : -1158 str -1159 } -1160 , -1161 str -1162 : -1163 { -1164 str -1165 : -1166 str -1167 , -1168 str -1169 : -1170 str -1171 } -1172 } -1173 } -1174 , -1175 { -1176 str -1177 : -1178 str -1179 , -1180 str -1181 : -1182 { -1183 str -1184 : -1185 str -1186 , -1187 str -1188 : -1189 num -1190 , -1191 str -1192 : -1193 { -1194 str -1195 : -1196 num -1197 , -1198 str -1199 : -1200 num -1201 } -1202 , -1203 str -1204 : -1205 str -1206 , -1207 str -1208 : -1209 num -1210 , -1211 str -1212 : -1213 { -1214 str -1215 : -1216 num -1217 , -1218 str -1219 : -1220 str -1221 , -1222 str -1223 : -1224 str -1225 , -1226 str -1227 : -1228 str -1229 , -1230 str -1231 : -1232 str -1233 , -1234 str -1235 : -1236 str -1237 } -1238 , -1239 str -1240 : -1241 { -1242 str -1243 : -1244 str -1245 , -1246 str -1247 : -1248 str -1249 } -1250 } -1251 } -1252 , -1253 { -1254 str -1255 : -1256 str -1257 , -1258 str -1259 : -1260 { -1261 str -1262 : -1263 str -1264 , -1265 str -1266 : -1267 num -1268 , -1269 str -1270 : -1271 { -1272 str -1273 : -1274 num -1275 , -1276 str -1277 : -1278 num -1279 } -1280 , -1281 str -1282 : -1283 str -1284 , -1285 str -1286 : -1287 num -1288 , -1289 str -1290 : -1291 { -1292 str -1293 : -1294 num -1295 , -1296 str -1297 : -1298 str -1299 , -1300 str -1301 : -1302 str -1303 , -1304 str -1305 : -1306 str -1307 , -1308 str -1309 : -1310 str -1311 , -1312 str -1313 : -1314 str -1315 } -1316 , -1317 str -1318 : -1319 { -1320 str -1321 : -1322 str -1323 , -1324 str -1325 : -1326 str -1327 } -1328 } -1329 } -1330 , -1331 { -1332 str -1333 : -1334 str -1335 , -1336 str -1337 : -1338 { -1339 str -1340 : -1341 str -1342 , -1343 str -1344 : -1345 num -1346 , -1347 str -1348 : -1349 { -1350 str -1351 : -1352 num -1353 , -1354 str -1355 : -1356 num -1357 } -1358 , -1359 str -1360 : -1361 str -1362 , -1363 str -1364 : -1365 num -1366 , -1367 str -1368 : -1369 { -1370 str -1371 : -1372 num -1373 , -1374 str -1375 : -1376 str -1377 , -1378 str -1379 : -1380 str -1381 , -1382 str -1383 : -1384 str -1385 , -1386 str -1387 : -1388 str -1389 , -1390 str -1391 : -1392 str -1393 } -1394 , -1395 str -1396 : -1397 { -1398 str -1399 : -1400 str -1401 , -1402 str -1403 : -1404 str -1405 } -1406 } -1407 } -1408 , -1409 { -1410 str -1411 : -1412 str -1413 , -1414 str -1415 : -1416 { -1417 str -1418 : -1419 str -1420 , -1421 str -1422 : -1423 num -1424 , -1425 str -1426 : -1427 { -1428 str -1429 : -1430 num -1431 , -1432 str -1433 : -1434 num -1435 } -1436 , -1437 str -1438 : -1439 str -1440 , -1441 str -1442 : -1443 num -1444 , -1445 str -1446 : -1447 { -1448 str -1449 : -1450 num -1451 , -1452 str -1453 : -1454 str -1455 , -1456 str -1457 : -1458 str -1459 , -1460 str -1461 : -1462 str -1463 , -1464 str -1465 : -1466 str -1467 , -1468 str -1469 : -1470 str -1471 } -1472 , -1473 str -1474 : -1475 { -1476 str -1477 : -1478 str -1479 , -1480 str -1481 : -1482 str -1483 } -1484 } -1485 } -1486 , -1487 { -1488 str -1489 : -1490 str -1491 , -1492 str -1493 : -1494 { -1495 str -1496 : -1497 str -1498 , -1499 str -1500 : -1501 num -1502 , -1503 str -1504 : -1505 { -1506 str -1507 : -1508 num -1509 , -1510 str -1511 : -1512 num -1513 } -1514 , -1515 str -1516 : -1517 str -1518 , -1519 str -1520 : -1521 num -1522 , -1523 str -1524 : -1525 { -1526 str -1527 : -1528 num -1529 , -1530 str -1531 : -1532 str -1533 , -1534 str -1535 : -1536 str -1537 , -1538 str -1539 : -1540 str -1541 , -1542 str -1543 : -1544 str -1545 , -1546 str -1547 : -1548 str -1549 } -1550 , -1551 str -1552 : -1553 { -1554 str -1555 : -1556 str -1557 , -1558 str -1559 : -1560 str -1561 } -1562 } -1563 } -1564 , -1565 { -1566 str -1567 : -1568 str -1569 , -1570 str -1571 : -1572 { -1573 str -1574 : -1575 str -1576 , -1577 str -1578 : -1579 num -1580 , -1581 str -1582 : -1583 { -1584 str -1585 : -1586 num -1587 , -1588 str -1589 : -1590 num -1591 } -1592 , -1593 str -1594 : -1595 str -1596 , -1597 str -1598 : -1599 num -1600 , -1601 str -1602 : -1603 { -1604 str -1605 : -1606 num -1607 , -1608 str -1609 : -1610 str -1611 , -1612 str -1613 : -1614 str -1615 , -1616 str -1617 : -1618 str -1619 , -1620 str -1621 : -1622 str -1623 , -1624 str -1625 : -1626 str -1627 } -1628 , -1629 str -1630 : -1631 { -1632 str -1633 : -1634 str -1635 , -1636 str -1637 : -1638 str -1639 } -1640 } -1641 } -1642 , -1643 { -1644 str -1645 : -1646 str -1647 , -1648 str -1649 : -1650 { -1651 str -1652 : -1653 str -1654 , -1655 str -1656 : -1657 num -1658 , -1659 str -1660 : -1661 { -1662 str -1663 : -1664 num -1665 , -1666 str -1667 : -1668 num -1669 } -1670 , -1671 str -1672 : -1673 str -1674 , -1675 str -1676 : -1677 num -1678 , -1679 str -1680 : -1681 { -1682 str -1683 : -1684 num -1685 , -1686 str -1687 : -1688 str -1689 , -1690 str -1691 : -1692 str -1693 , -1694 str -1695 : -1696 str -1697 , -1698 str -1699 : -1700 str -1701 , -1702 str -1703 : -1704 str -1705 } -1706 , -1707 str -1708 : -1709 { -1710 str -1711 : -1712 str -1713 , -1714 str -1715 : -1716 str -1717 } -1718 } -1719 } -1720 , -1721 { -1722 str -1723 : -1724 str -1725 , -1726 str -1727 : -1728 { -1729 str -1730 : -1731 str -1732 , -1733 str -1734 : -1735 num -1736 , -1737 str -1738 : -1739 { -1740 str -1741 : -1742 num -1743 , -1744 str -1745 : -1746 num -1747 } -1748 , -1749 str -1750 : -1751 str -1752 , -1753 str -1754 : -1755 num -1756 , -1757 str -1758 : -1759 { -1760 str -1761 : -1762 num -1763 , -1764 str -1765 : -1766 str -1767 , -1768 str -1769 : -1770 str -1771 , -1772 str -1773 : -1774 str -1775 , -1776 str -1777 : -1778 str -1779 , -1780 str -1781 : -1782 str -1783 } -1784 , -1785 str -1786 : -1787 { -1788 str -1789 : -1790 str -1791 , -1792 str -1793 : -1794 str -1795 } -1796 } -1797 } -1798 , -1799 { -1800 str -1801 : -1802 str -1803 , -1804 str -1805 : -1806 { -1807 str -1808 : -1809 str -1810 , -1811 str -1812 : -1813 num -1814 , -1815 str -1816 : -1817 { -1818 str -1819 : -1820 num -1821 , -1822 str -1823 : -1824 num -1825 } -1826 , -1827 str -1828 : -1829 str -1830 , -1831 str -1832 : -1833 num -1834 , -1835 str -1836 : -1837 { -1838 str -1839 : -1840 num -1841 , -1842 str -1843 : -1844 str -1845 , -1846 str -1847 : -1848 str -1849 , -1850 str -1851 : -1852 str -1853 , -1854 str -1855 : -1856 str -1857 , -1858 str -1859 : -1860 str -1861 } -1862 , -1863 str -1864 : -1865 { -1866 str -1867 : -1868 str -1869 , -1870 str -1871 : -1872 str -1873 } -1874 } -1875 } -1876 , -1877 { -1878 str -1879 : -1880 str -1881 , -1882 str -1883 : -1884 { -1885 str -1886 : -1887 str -1888 , -1889 str -1890 : -1891 num -1892 , -1893 str -1894 : -1895 { -1896 str -1897 : -1898 num -1899 , -1900 str -1901 : -1902 num -1903 } -1904 , -1905 str -1906 : -1907 str -1908 , -1909 str -1910 : -1911 num -1912 , -1913 str -1914 : -1915 { -1916 str -1917 : -1918 num -1919 , -1920 str -1921 : -1922 str -1923 , -1924 str -1925 : -1926 str -1927 , -1928 str -1929 : -1930 str -1931 , -1932 str -1933 : -1934 str -1935 , -1936 str -1937 : -1938 str -1939 } -1940 , -1941 str -1942 : -1943 { -1944 str -1945 : -1946 str -1947 , -1948 str -1949 : -1950 str -1951 } -1952 } -1953 } -1954 , -1955 { -1956 str -1957 : -1958 str -1959 , -1960 str -1961 : -1962 { -1963 str -1964 : -1965 str -1966 , -1967 str -1968 : -1969 num -1970 , -1971 str -1972 : -1973 { -1974 str -1975 : -1976 num -1977 , -1978 str -1979 : -1980 num -1981 } -1982 , -1983 str -1984 : -1985 str -1986 , -1987 str -1988 : -1989 num -1990 , -1991 str -1992 : -1993 { -1994 str -1995 : -1996 num -1997 , -1998 str -1999 : -2000 str -2001 , -2002 str -2003 : -2004 str -2005 , -2006 str -2007 : -2008 str -2009 , -2010 str -2011 : -2012 str -2013 , -2014 str -2015 : -2016 str -2017 } -2018 , -2019 str -2020 : -2021 { -2022 str -2023 : -2024 str -2025 , -2026 str -2027 : -2028 str -2029 } -2030 } -2031 } -2032 , -2033 { -2034 str -2035 : -2036 str -2037 , -2038 str -2039 : -2040 { -2041 str -2042 : -2043 str -2044 , -2045 str -2046 : -2047 num -2048 , -2049 str -2050 : -2051 { -2052 str -2053 : -2054 num -2055 , -2056 str -2057 : -2058 num -2059 } -2060 , -2061 str -2062 : -2063 str -2064 , -2065 str -2066 : -2067 num -2068 , -2069 str -2070 : -2071 { -2072 str -2073 : -2074 num -2075 , -2076 str -2077 : -2078 str -2079 , -2080 str -2081 : -2082 str -2083 , -2084 str -2085 : -2086 str -2087 , -2088 str -2089 : -2090 str -2091 , -2092 str -2093 : -2094 str -2095 } -2096 , -2097 str -2098 : -2099 { -2100 str -2101 : -2102 str -2103 , -2104 str -2105 : -2106 str -2107 } -2108 } -2109 } -2110 , -2111 { -2112 str -2113 : -2114 str -2115 , -2116 str -2117 : -2118 { -2119 str -2120 : -2121 str -2122 , -2123 str -2124 : -2125 num -2126 , -2127 str -2128 : -2129 { -2130 str -2131 : -2132 num -2133 , -2134 str -2135 : -2136 num -2137 } -2138 , -2139 str -2140 : -2141 str -2142 , -2143 str -2144 : -2145 num -2146 , -2147 str -2148 : -2149 { -2150 str -2151 : -2152 num -2153 , -2154 str -2155 : -2156 str -2157 , -2158 str -2159 : -2160 str -2161 , -2162 str -2163 : -2164 str -2165 , -2166 str -2167 : -2168 str -2169 , -2170 str -2171 : -2172 str -2173 } -2174 , -2175 str -2176 : -2177 { -2178 str -2179 : -2180 str -2181 , -2182 str -2183 : -2184 str -2185 } -2186 } -2187 } -2188 , -2189 { -2190 str -2191 : -2192 str -2193 , -2194 str -2195 : -2196 { -2197 str -2198 : -2199 str -2200 , -2201 str -2202 : -2203 num -2204 , -2205 str -2206 : -2207 { -2208 str -2209 : -2210 num -2211 , -2212 str -2213 : -2214 num -2215 } -2216 , -2217 str -2218 : -2219 str -2220 , -2221 str -2222 : -2223 num -2224 , -2225 str -2226 : -2227 { -2228 str -2229 : -2230 num -2231 , -2232 str -2233 : -2234 str -2235 , -2236 str -2237 : -2238 str -2239 , -2240 str -2241 : -2242 str -2243 , -2244 str -2245 : -2246 str -2247 , -2248 str -2249 : -2250 str -2251 } -2252 , -2253 str -2254 : -2255 { -2256 str -2257 : -2258 str -2259 , -2260 str -2261 : -2262 str -2263 } -2264 } -2265 } -2266 , -2267 { -2268 str -2269 : -2270 str -2271 , -2272 str -2273 : -2274 { -2275 str -2276 : -2277 str -2278 , -2279 str -2280 : -2281 num -2282 , -2283 str -2284 : -2285 { -2286 str -2287 : -2288 num -2289 , -2290 str -2291 : -2292 num -2293 } -2294 , -2295 str -2296 : -2297 str -2298 , -2299 str -2300 : -2301 num -2302 , -2303 str -2304 : -2305 { -2306 str -2307 : -2308 num -2309 , -2310 str -2311 : -2312 str -2313 , -2314 str -2315 : -2316 str -2317 , -2318 str -2319 : -2320 str -2321 , -2322 str -2323 : -2324 str -2325 , -2326 str -2327 : -2328 str -2329 } -2330 , -2331 str -2332 : -2333 { -2334 str -2335 : -2336 str -2337 , -2338 str -2339 : -2340 str -2341 } -2342 } -2343 } -2344 , -2345 { -2346 str -2347 : -2348 str -2349 , -2350 str -2351 : -2352 { -2353 str -2354 : -2355 str -2356 , -2357 str -2358 : -2359 num -2360 , -2361 str -2362 : -2363 { -2364 str -2365 : -2366 num -2367 , -2368 str -2369 : -2370 num -2371 } -2372 , -2373 str -2374 : -2375 str -2376 , -2377 str -2378 : -2379 num -2380 , -2381 str -2382 : -2383 { -2384 str -2385 : -2386 num -2387 , -2388 str -2389 : -2390 str -2391 , -2392 str -2393 : -2394 str -2395 , -2396 str -2397 : -2398 str -2399 , -2400 str -2401 : -2402 str -2403 , -2404 str -2405 : -2406 str -2407 } -2408 , -2409 str -2410 : -2411 { -2412 str -2413 : -2414 str -2415 , -2416 str -2417 : -2418 str -2419 } -2420 } -2421 } -2422 , -2423 { -2424 str -2425 : -2426 str -2427 , -2428 str -2429 : -2430 { -2431 str -2432 : -2433 str -2434 , -2435 str -2436 : -2437 num -2438 , -2439 str -2440 : -2441 { -2442 str -2443 : -2444 num -2445 , -2446 str -2447 : -2448 num -2449 } -2450 , -2451 str -2452 : -2453 str -2454 , -2455 str -2456 : -2457 num -2458 , -2459 str -2460 : -2461 { -2462 str -2463 : -2464 num -2465 , -2466 str -2467 : -2468 str -2469 , -2470 str -2471 : -2472 str -2473 , -2474 str -2475 : -2476 str -2477 , -2478 str -2479 : -2480 str -2481 , -2482 str -2483 : -2484 str -2485 } -2486 , -2487 str -2488 : -2489 { -2490 str -2491 : -2492 str -2493 , -2494 str -2495 : -2496 str -2497 } -2498 } -2499 } -2500 , -2501 { -2502 str -2503 : -2504 str -2505 , -2506 str -2507 : -2508 { -2509 str -2510 : -2511 str -2512 , -2513 str -2514 : -2515 num -2516 , -2517 str -2518 : -2519 { -2520 str -2521 : -2522 num -2523 , -2524 str -2525 : -2526 num -2527 } -2528 , -2529 str -2530 : -2531 str -2532 , -2533 str -2534 : -2535 num -2536 , -2537 str -2538 : -2539 { -2540 str -2541 : -2542 num -2543 , -2544 str -2545 : -2546 str -2547 , -2548 str -2549 : -2550 str -2551 , -2552 str -2553 : -2554 str -2555 , -2556 str -2557 : -2558 str -2559 , -2560 str -2561 : -2562 str -2563 } -2564 , -2565 str -2566 : -2567 { -2568 str -2569 : -2570 str -2571 , -2572 str -2573 : -2574 str -2575 } -2576 } -2577 } -2578 , -2579 { -2580 str -2581 : -2582 str -2583 , -2584 str -2585 : -2586 { -2587 str -2588 : -2589 str -2590 , -2591 str -2592 : -2593 num -2594 , -2595 str -2596 : -2597 { -2598 str -2599 : -2600 num -2601 , -2602 str -2603 : -2604 num -2605 } -2606 , -2607 str -2608 : -2609 str -2610 , -2611 str -2612 : -2613 num -2614 , -2615 str -2616 : -2617 { -2618 str -2619 : -2620 num -2621 , -2622 str -2623 : -2624 str -2625 , -2626 str -2627 : -2628 str -2629 , -2630 str -2631 : -2632 str -2633 , -2634 str -2635 : -2636 str -2637 , -2638 str -2639 : -2640 str -2641 } -2642 , -2643 str -2644 : -2645 { -2646 str -2647 : -2648 str -2649 , -2650 str -2651 : -2652 str -2653 } -2654 } -2655 } -2656 , -2657 { -2658 str -2659 : -2660 str -2661 , -2662 str -2663 : -2664 { -2665 str -2666 : -2667 str -2668 , -2669 str -2670 : -2671 num -2672 , -2673 str -2674 : -2675 { -2676 str -2677 : -2678 num -2679 , -2680 str -2681 : -2682 num -2683 } -2684 , -2685 str -2686 : -2687 str -2688 , -2689 str -2690 : -2691 num -2692 , -2693 str -2694 : -2695 { -2696 str -2697 : -2698 num -2699 , -2700 str -2701 : -2702 str -2703 , -2704 str -2705 : -2706 str -2707 , -2708 str -2709 : -2710 str -2711 , -2712 str -2713 : -2714 str -2715 , -2716 str -2717 : -2718 str -2719 } -2720 , -2721 str -2722 : -2723 { -2724 str -2725 : -2726 str -2727 , -2728 str -2729 : -2730 str -2731 } -2732 } -2733 } -2734 , -2735 { -2736 str -2737 : -2738 str -2739 , -2740 str -2741 : -2742 { -2743 str -2744 : -2745 str -2746 , -2747 str -2748 : -2749 num -2750 , -2751 str -2752 : -2753 { -2754 str -2755 : -2756 num -2757 , -2758 str -2759 : -2760 num -2761 } -2762 , -2763 str -2764 : -2765 str -2766 , -2767 str -2768 : -2769 num -2770 , -2771 str -2772 : -2773 { -2774 str -2775 : -2776 num -2777 , -2778 str -2779 : -2780 str -2781 , -2782 str -2783 : -2784 str -2785 , -2786 str -2787 : -2788 str -2789 , -2790 str -2791 : -2792 str -2793 , -2794 str -2795 : -2796 str -2797 } -2798 , -2799 str -2800 : -2801 { -2802 str -2803 : -2804 str -2805 , -2806 str -2807 : -2808 str -2809 } -2810 } -2811 } -2812 , -2813 { -2814 str -2815 : -2816 str -2817 , -2818 str -2819 : -2820 { -2821 str -2822 : -2823 str -2824 , -2825 str -2826 : -2827 num -2828 , -2829 str -2830 : -2831 { -2832 str -2833 : -2834 num -2835 , -2836 str -2837 : -2838 num -2839 } -2840 , -2841 str -2842 : -2843 str -2844 , -2845 str -2846 : -2847 num -2848 , -2849 str -2850 : -2851 { -2852 str -2853 : -2854 num -2855 , -2856 str -2857 : -2858 str -2859 , -2860 str -2861 : -2862 str -2863 , -2864 str -2865 : -2866 str -2867 , -2868 str -2869 : -2870 str -2871 , -2872 str -2873 : -2874 str -2875 } -2876 , -2877 str -2878 : -2879 { -2880 str -2881 : -2882 str -2883 , -2884 str -2885 : -2886 str -2887 } -2888 } -2889 } -2890 , -2891 { -2892 str -2893 : -2894 str -2895 , -2896 str -2897 : -2898 { -2899 str -2900 : -2901 str -2902 , -2903 str -2904 : -2905 num -2906 , -2907 str -2908 : -2909 { -2910 str -2911 : -2912 num -2913 , -2914 str -2915 : -2916 num -2917 } -2918 , -2919 str -2920 : -2921 str -2922 , -2923 str -2924 : -2925 num -2926 , -2927 str -2928 : -2929 { -2930 str -2931 : -2932 num -2933 , -2934 str -2935 : -2936 str -2937 , -2938 str -2939 : -2940 str -2941 , -2942 str -2943 : -2944 str -2945 , -2946 str -2947 : -2948 str -2949 , -2950 str -2951 : -2952 str -2953 } -2954 , -2955 str -2956 : -2957 { -2958 str -2959 : -2960 str -2961 , -2962 str -2963 : -2964 str -2965 } -2966 } -2967 } -2968 , -2969 { -2970 str -2971 : -2972 str -2973 , -2974 str -2975 : -2976 { -2977 str -2978 : -2979 str -2980 , -2981 str -2982 : -2983 num -2984 , -2985 str -2986 : -2987 { -2988 str -2989 : -2990 num -2991 , -2992 str -2993 : -2994 num -2995 } -2996 , -2997 str -2998 : -2999 str -3000 , -3001 str -3002 : -3003 num -3004 , -3005 str -3006 : -3007 { -3008 str -3009 : -3010 num -3011 , -3012 str -3013 : -3014 str -3015 , -3016 str -3017 : -3018 str -3019 , -3020 str -3021 : -3022 str -3023 , -3024 str -3025 : -3026 str -3027 , -3028 str -3029 : -3030 str -3031 } -3032 , -3033 str -3034 : -3035 { -3036 str -3037 : -3038 str -3039 , -3040 str -3041 : -3042 str -3043 } -3044 } -3045 } -3046 , -3047 { -3048 str -3049 : -3050 str -3051 , -3052 str -3053 : -3054 { -3055 str -3056 : -3057 str -3058 , -3059 str -3060 : -3061 num -3062 , -3063 str -3064 : -3065 { -3066 str -3067 : -3068 num -3069 , -3070 str -3071 : -3072 num -3073 } -3074 , -3075 str -3076 : -3077 str -3078 , -3079 str -3080 : -3081 num -3082 , -3083 str -3084 : -3085 { -3086 str -3087 : -3088 num -3089 , -3090 str -3091 : -3092 str -3093 , -3094 str -3095 : -3096 str -3097 , -3098 str -3099 : -3100 str -3101 , -3102 str -3103 : -3104 str -3105 , -3106 str -3107 : -3108 str -3109 } -3110 , -3111 str -3112 : -3113 { -3114 str -3115 : -3116 str -3117 , -3118 str -3119 : -3120 str -3121 } -3122 } -3123 } -3124 , -3125 { -3126 str -3127 : -3128 str -3129 , -3130 str -3131 : -3132 { -3133 str -3134 : -3135 str -3136 , -3137 str -3138 : -3139 num -3140 , -3141 str -3142 : -3143 { -3144 str -3145 : -3146 num -3147 , -3148 str -3149 : -3150 num -3151 } -3152 , -3153 str -3154 : -3155 str -3156 , -3157 str -3158 : -3159 num -3160 , -3161 str -3162 : -3163 { -3164 str -3165 : -3166 num -3167 , -3168 str -3169 : -3170 str -3171 , -3172 str -3173 : -3174 str -3175 , -3176 str -3177 : -3178 str -3179 , -3180 str -3181 : -3182 str -3183 , -3184 str -3185 : -3186 str -3187 } -3188 , -3189 str -3190 : -3191 { -3192 str -3193 : -3194 str -3195 , -3196 str -3197 : -3198 str -3199 } -3200 } -3201 } -3202 , -3203 { -3204 str -3205 : -3206 str -3207 , -3208 str -3209 : -3210 { -3211 str -3212 : -3213 str -3214 , -3215 str -3216 : -3217 num -3218 , -3219 str -3220 : -3221 { -3222 str -3223 : -3224 num -3225 , -3226 str -3227 : -3228 num -3229 } -3230 , -3231 str -3232 : -3233 str -3234 , -3235 str -3236 : -3237 num -3238 , -3239 str -3240 : -3241 { -3242 str -3243 : -3244 num -3245 , -3246 str -3247 : -3248 str -3249 , -3250 str -3251 : -3252 str -3253 , -3254 str -3255 : -3256 str -3257 , -3258 str -3259 : -3260 str -3261 , -3262 str -3263 : -3264 str -3265 } -3266 , -3267 str -3268 : -3269 { -3270 str -3271 : -3272 str -3273 , -3274 str -3275 : -3276 str -3277 } -3278 } -3279 } -3280 , -3281 { -3282 str -3283 : -3284 str -3285 , -3286 str -3287 : -3288 { -3289 str -3290 : -3291 str -3292 , -3293 str -3294 : -3295 num -3296 , -3297 str -3298 : -3299 { -3300 str -3301 : -3302 num -3303 , -3304 str -3305 : -3306 num -3307 } -3308 , -3309 str -3310 : -3311 str -3312 , -3313 str -3314 : -3315 num -3316 , -3317 str -3318 : -3319 { -3320 str -3321 : -3322 num -3323 , -3324 str -3325 : -3326 str -3327 , -3328 str -3329 : -3330 str -3331 , -3332 str -3333 : -3334 str -3335 , -3336 str -3337 : -3338 str -3339 , -3340 str -3341 : -3342 str -3343 } -3344 , -3345 str -3346 : -3347 { -3348 str -3349 : -3350 str -3351 , -3352 str -3353 : -3354 str -3355 } -3356 } -3357 } -3358 , -3359 { -3360 str -3361 : -3362 str -3363 , -3364 str -3365 : -3366 { -3367 str -3368 : -3369 str -3370 , -3371 str -3372 : -3373 num -3374 , -3375 str -3376 : -3377 { -3378 str -3379 : -3380 num -3381 , -3382 str -3383 : -3384 num -3385 } -3386 , -3387 str -3388 : -3389 str -3390 , -3391 str -3392 : -3393 num -3394 , -3395 str -3396 : -3397 { -3398 str -3399 : -3400 num -3401 , -3402 str -3403 : -3404 str -3405 , -3406 str -3407 : -3408 str -3409 , -3410 str -3411 : -3412 str -3413 , -3414 str -3415 : -3416 str -3417 , -3418 str -3419 : -3420 str -3421 } -3422 , -3423 str -3424 : -3425 { -3426 str -3427 : -3428 str -3429 , -3430 str -3431 : -3432 str -3433 } -3434 } -3435 } -3436 , -3437 { -3438 str -3439 : -3440 str -3441 , -3442 str -3443 : -3444 { -3445 str -3446 : -3447 str -3448 , -3449 str -3450 : -3451 num -3452 , -3453 str -3454 : -3455 { -3456 str -3457 : -3458 num -3459 , -3460 str -3461 : -3462 num -3463 } -3464 , -3465 str -3466 : -3467 str -3468 , -3469 str -3470 : -3471 num -3472 , -3473 str -3474 : -3475 { -3476 str -3477 : -3478 num -3479 , -3480 str -3481 : -3482 str -3483 , -3484 str -3485 : -3486 str -3487 , -3488 str -3489 : -3490 str -3491 , -3492 str -3493 : -3494 str -3495 , -3496 str -3497 : -3498 str -3499 } -3500 , -3501 str -3502 : -3503 { -3504 str -3505 : -3506 str -3507 , -3508 str -3509 : -3510 str -3511 } -3512 } -3513 } -3514 , -3515 { -3516 str -3517 : -3518 str -3519 , -3520 str -3521 : -3522 { -3523 str -3524 : -3525 str -3526 , -3527 str -3528 : -3529 num -3530 , -3531 str -3532 : -3533 { -3534 str -3535 : -3536 num -3537 , -3538 str -3539 : -3540 num -3541 } -3542 , -3543 str -3544 : -3545 str -3546 , -3547 str -3548 : -3549 num -3550 , -3551 str -3552 : -3553 { -3554 str -3555 : -3556 num -3557 , -3558 str -3559 : -3560 str -3561 , -3562 str -3563 : -3564 str -3565 , -3566 str -3567 : -3568 str -3569 , -3570 str -3571 : -3572 str -3573 , -3574 str -3575 : -3576 str -3577 } -3578 , -3579 str -3580 : -3581 { -3582 str -3583 : -3584 str -3585 , -3586 str -3587 : -3588 str -3589 } -3590 } -3591 } -3592 , -3593 { -3594 str -3595 : -3596 str -3597 , -3598 str -3599 : -3600 { -3601 str -3602 : -3603 str -3604 , -3605 str -3606 : -3607 num -3608 , -3609 str -3610 : -3611 { -3612 str -3613 : -3614 num -3615 , -3616 str -3617 : -3618 num -3619 } -3620 , -3621 str -3622 : -3623 str -3624 , -3625 str -3626 : -3627 num -3628 , -3629 str -3630 : -3631 { -3632 str -3633 : -3634 num -3635 , -3636 str -3637 : -3638 str -3639 , -3640 str -3641 : -3642 str -3643 , -3644 str -3645 : -3646 str -3647 , -3648 str -3649 : -3650 str -3651 , -3652 str -3653 : -3654 str -3655 } -3656 , -3657 str -3658 : -3659 { -3660 str -3661 : -3662 str -3663 , -3664 str -3665 : -3666 str -3667 } -3668 } -3669 } -3670 , -3671 { -3672 str -3673 : -3674 str -3675 , -3676 str -3677 : -3678 { -3679 str -3680 : -3681 str -3682 , -3683 str -3684 : -3685 num -3686 , -3687 str -3688 : -3689 { -3690 str -3691 : -3692 num -3693 , -3694 str -3695 : -3696 num -3697 } -3698 , -3699 str -3700 : -3701 str -3702 , -3703 str -3704 : -3705 num -3706 , -3707 str -3708 : -3709 { -3710 str -3711 : -3712 num -3713 , -3714 str -3715 : -3716 str -3717 , -3718 str -3719 : -3720 str -3721 , -3722 str -3723 : -3724 str -3725 , -3726 str -3727 : -3728 str -3729 , -3730 str -3731 : -3732 str -3733 } -3734 , -3735 str -3736 : -3737 { -3738 str -3739 : -3740 str -3741 , -3742 str -3743 : -3744 str -3745 } -3746 } -3747 } -3748 , -3749 { -3750 str -3751 : -3752 str -3753 , -3754 str -3755 : -3756 { -3757 str -3758 : -3759 str -3760 , -3761 str -3762 : -3763 num -3764 , -3765 str -3766 : -3767 { -3768 str -3769 : -3770 num -3771 , -3772 str -3773 : -3774 num -3775 } -3776 , -3777 str -3778 : -3779 str -3780 , -3781 str -3782 : -3783 num -3784 , -3785 str -3786 : -3787 { -3788 str -3789 : -3790 num -3791 , -3792 str -3793 : -3794 str -3795 , -3796 str -3797 : -3798 str -3799 , -3800 str -3801 : -3802 str -3803 , -3804 str -3805 : -3806 str -3807 , -3808 str -3809 : -3810 str -3811 } -3812 , -3813 str -3814 : -3815 { -3816 str -3817 : -3818 str -3819 , -3820 str -3821 : -3822 str -3823 } -3824 } -3825 } -3826 , -3827 { -3828 str -3829 : -3830 str -3831 , -3832 str -3833 : -3834 { -3835 str -3836 : -3837 str -3838 , -3839 str -3840 : -3841 num -3842 , -3843 str -3844 : -3845 { -3846 str -3847 : -3848 num -3849 , -3850 str -3851 : -3852 num -3853 } -3854 , -3855 str -3856 : -3857 str -3858 , -3859 str -3860 : -3861 num -3862 , -3863 str -3864 : -3865 { -3866 str -3867 : -3868 num -3869 , -3870 str -3871 : -3872 str -3873 , -3874 str -3875 : -3876 str -3877 , -3878 str -3879 : -3880 str -3881 , -3882 str -3883 : -3884 str -3885 , -3886 str -3887 : -3888 str -3889 } -3890 , -3891 str -3892 : -3893 { -3894 str -3895 : -3896 str -3897 , -3898 str -3899 : -3900 str -3901 } -3902 } -3903 } -3904 , -3905 { -3906 str -3907 : -3908 str -3909 , -3910 str -3911 : -3912 { -3913 str -3914 : -3915 str -3916 , -3917 str -3918 : -3919 num -3920 , -3921 str -3922 : -3923 { -3924 str -3925 : -3926 num -3927 , -3928 str -3929 : -3930 num -3931 } -3932 , -3933 str -3934 : -3935 str -3936 , -3937 str -3938 : -3939 num -3940 , -3941 str -3942 : -3943 { -3944 str -3945 : -3946 num -3947 , -3948 str -3949 : -3950 str -3951 , -3952 str -3953 : -3954 str -3955 , -3956 str -3957 : -3958 str -3959 , -3960 str -3961 : -3962 str -3963 , -3964 str -3965 : -3966 str -3967 } -3968 , -3969 str -3970 : -3971 { -3972 str -3973 : -3974 str -3975 , -3976 str -3977 : -3978 str -3979 } -3980 } -3981 } -3982 , -3983 { -3984 str -3985 : -3986 str -3987 , -3988 str -3989 : -3990 { -3991 str -3992 : -3993 str -3994 , -3995 str -3996 : -3997 num -3998 , -3999 str -4000 : -4001 { -4002 str -4003 : -4004 num -4005 , -4006 str -4007 : -4008 num -4009 } -4010 , -4011 str -4012 : -4013 str -4014 , -4015 str -4016 : -4017 num -4018 , -4019 str -4020 : -4021 { -4022 str -4023 : -4024 num -4025 , -4026 str -4027 : -4028 str -4029 , -4030 str -4031 : -4032 str -4033 , -4034 str -4035 : -4036 str -4037 , -4038 str -4039 : -4040 str -4041 , -4042 str -4043 : -4044 str -4045 } -4046 , -4047 str -4048 : -4049 { -4050 str -4051 : -4052 str -4053 , -4054 str -4055 : -4056 str -4057 } -4058 } -4059 } -4060 , -4061 { -4062 str -4063 : -4064 str -4065 , -4066 str -4067 : -4068 { -4069 str -4070 : -4071 str -4072 , -4073 str -4074 : -4075 num -4076 , -4077 str -4078 : -4079 { -4080 str -4081 : -4082 num -4083 , -4084 str -4085 : -4086 num -4087 } -4088 , -4089 str -4090 : -4091 str -4092 , -4093 str -4094 : -4095 num -4096 , -4097 str -4098 : -4099 { -4100 str -4101 : -4102 num -4103 , -4104 str -4105 : -4106 str -4107 , -4108 str -4109 : -4110 str -4111 , -4112 str -4113 : -4114 str -4115 , -4116 str -4117 : -4118 str -4119 , -4120 str -4121 : -4122 str -4123 } -4124 , -4125 str -4126 : -4127 { -4128 str -4129 : -4130 str -4131 , -4132 str -4133 : -4134 str -4135 } -4136 } -4137 } -4138 , -4139 { -4140 str -4141 : -4142 str -4143 , -4144 str -4145 : -4146 { -4147 str -4148 : -4149 str -4150 , -4151 str -4152 : -4153 num -4154 , -4155 str -4156 : -4157 { -4158 str -4159 : -4160 num -4161 , -4162 str -4163 : -4164 num -4165 } -4166 , -4167 str -4168 : -4169 str -4170 , -4171 str -4172 : -4173 num -4174 , -4175 str -4176 : -4177 { -4178 str -4179 : -4180 num -4181 , -4182 str -4183 : -4184 str -4185 , -4186 str -4187 : -4188 str -4189 , -4190 str -4191 : -4192 str -4193 , -4194 str -4195 : -4196 str -4197 , -4198 str -4199 : -4200 str -4201 } -4202 , -4203 str -4204 : -4205 { -4206 str -4207 : -4208 str -4209 , -4210 str -4211 : -4212 str -4213 } -4214 } -4215 } -4216 , -4217 { -4218 str -4219 : -4220 str -4221 , -4222 str -4223 : -4224 { -4225 str -4226 : -4227 str -4228 , -4229 str -4230 : -4231 num -4232 , -4233 str -4234 : -4235 { -4236 str -4237 : -4238 num -4239 , -4240 str -4241 : -4242 num -4243 } -4244 , -4245 str -4246 : -4247 str -4248 , -4249 str -4250 : -4251 num -4252 , -4253 str -4254 : -4255 { -4256 str -4257 : -4258 num -4259 , -4260 str -4261 : -4262 str -4263 , -4264 str -4265 : -4266 str -4267 , -4268 str -4269 : -4270 str -4271 , -4272 str -4273 : -4274 str -4275 , -4276 str -4277 : -4278 str -4279 } -4280 , -4281 str -4282 : -4283 { -4284 str -4285 : -4286 str -4287 , -4288 str -4289 : -4290 str -4291 } -4292 } -4293 } -4294 , -4295 { -4296 str -4297 : -4298 str -4299 , -4300 str -4301 : -4302 { -4303 str -4304 : -4305 str -4306 , -4307 str -4308 : -4309 num -4310 , -4311 str -4312 : -4313 { -4314 str -4315 : -4316 num -4317 , -4318 str -4319 : -4320 num -4321 } -4322 , -4323 str -4324 : -4325 str -4326 , -4327 str -4328 : -4329 num -4330 , -4331 str -4332 : -4333 { -4334 str -4335 : -4336 num -4337 , -4338 str -4339 : -4340 str -4341 , -4342 str -4343 : -4344 str -4345 , -4346 str -4347 : -4348 str -4349 , -4350 str -4351 : -4352 str -4353 , -4354 str -4355 : -4356 str -4357 } -4358 , -4359 str -4360 : -4361 { -4362 str -4363 : -4364 str -4365 , -4366 str -4367 : -4368 str -4369 } -4370 } -4371 } -4372 , -4373 { -4374 str -4375 : -4376 str -4377 , -4378 str -4379 : -4380 { -4381 str -4382 : -4383 str -4384 , -4385 str -4386 : -4387 num -4388 , -4389 str -4390 : -4391 { -4392 str -4393 : -4394 num -4395 , -4396 str -4397 : -4398 num -4399 } -4400 , -4401 str -4402 : -4403 str -4404 , -4405 str -4406 : -4407 num -4408 , -4409 str -4410 : -4411 { -4412 str -4413 : -4414 num -4415 , -4416 str -4417 : -4418 str -4419 , -4420 str -4421 : -4422 str -4423 , -4424 str -4425 : -4426 str -4427 , -4428 str -4429 : -4430 str -4431 , -4432 str -4433 : -4434 str -4435 } -4436 , -4437 str -4438 : -4439 { -4440 str -4441 : -4442 str -4443 , -4444 str -4445 : -4446 str -4447 } -4448 } -4449 } -4450 , -4451 { -4452 str -4453 : -4454 str -4455 , -4456 str -4457 : -4458 { -4459 str -4460 : -4461 str -4462 , -4463 str -4464 : -4465 num -4466 , -4467 str -4468 : -4469 { -4470 str -4471 : -4472 num -4473 , -4474 str -4475 : -4476 num -4477 } -4478 , -4479 str -4480 : -4481 str -4482 , -4483 str -4484 : -4485 num -4486 , -4487 str -4488 : -4489 { -4490 str -4491 : -4492 num -4493 , -4494 str -4495 : -4496 str -4497 , -4498 str -4499 : -4500 str -4501 , -4502 str -4503 : -4504 str -4505 , -4506 str -4507 : -4508 str -4509 , -4510 str -4511 : -4512 str -4513 } -4514 , -4515 str -4516 : -4517 { -4518 str -4519 : -4520 str -4521 , -4522 str -4523 : -4524 str -4525 } -4526 } -4527 } -4528 , -4529 { -4530 str -4531 : -4532 str -4533 , -4534 str -4535 : -4536 { -4537 str -4538 : -4539 str -4540 , -4541 str -4542 : -4543 num -4544 , -4545 str -4546 : -4547 { -4548 str -4549 : -4550 num -4551 , -4552 str -4553 : -4554 num -4555 } -4556 , -4557 str -4558 : -4559 str -4560 , -4561 str -4562 : -4563 num -4564 , -4565 str -4566 : -4567 { -4568 str -4569 : -4570 num -4571 , -4572 str -4573 : -4574 str -4575 , -4576 str -4577 : -4578 str -4579 , -4580 str -4581 : -4582 str -4583 , -4584 str -4585 : -4586 str -4587 , -4588 str -4589 : -4590 str -4591 } -4592 , -4593 str -4594 : -4595 { -4596 str -4597 : -4598 str -4599 , -4600 str -4601 : -4602 str -4603 } -4604 } -4605 } -4606 , -4607 { -4608 str -4609 : -4610 str -4611 , -4612 str -4613 : -4614 { -4615 str -4616 : -4617 str -4618 , -4619 str -4620 : -4621 num -4622 , -4623 str -4624 : -4625 { -4626 str -4627 : -4628 num -4629 , -4630 str -4631 : -4632 num -4633 } -4634 , -4635 str -4636 : -4637 str -4638 , -4639 str -4640 : -4641 num -4642 , -4643 str -4644 : -4645 { -4646 str -4647 : -4648 num -4649 , -4650 str -4651 : -4652 str -4653 , -4654 str -4655 : -4656 str -4657 , -4658 str -4659 : -4660 str -4661 , -4662 str -4663 : -4664 str -4665 , -4666 str -4667 : -4668 str -4669 } -4670 , -4671 str -4672 : -4673 { -4674 str -4675 : -4676 str -4677 , -4678 str -4679 : -4680 str -4681 } -4682 } -4683 } -4684 , -4685 { -4686 str -4687 : -4688 str -4689 , -4690 str -4691 : -4692 { -4693 str -4694 : -4695 str -4696 , -4697 str -4698 : -4699 num -4700 , -4701 str -4702 : -4703 { -4704 str -4705 : -4706 num -4707 , -4708 str -4709 : -4710 num -4711 } -4712 , -4713 str -4714 : -4715 str -4716 , -4717 str -4718 : -4719 num -4720 , -4721 str -4722 : -4723 { -4724 str -4725 : -4726 num -4727 , -4728 str -4729 : -4730 str -4731 , -4732 str -4733 : -4734 str -4735 , -4736 str -4737 : -4738 str -4739 , -4740 str -4741 : -4742 str -4743 , -4744 str -4745 : -4746 str -4747 } -4748 , -4749 str -4750 : -4751 { -4752 str -4753 : -4754 str -4755 , -4756 str -4757 : -4758 str -4759 } -4760 } -4761 } -4762 , -4763 { -4764 str -4765 : -4766 str -4767 , -4768 str -4769 : -4770 { -4771 str -4772 : -4773 str -4774 , -4775 str -4776 : -4777 num -4778 , -4779 str -4780 : -4781 { -4782 str -4783 : -4784 num -4785 , -4786 str -4787 : -4788 num -4789 } -4790 , -4791 str -4792 : -4793 str -4794 , -4795 str -4796 : -4797 num -4798 , -4799 str -4800 : -4801 { -4802 str -4803 : -4804 num -4805 , -4806 str -4807 : -4808 str -4809 , -4810 str -4811 : -4812 str -4813 , -4814 str -4815 : -4816 str -4817 , -4818 str -4819 : -4820 str -4821 , -4822 str -4823 : -4824 str -4825 } -4826 , -4827 str -4828 : -4829 { -4830 str -4831 : -4832 str -4833 , -4834 str -4835 : -4836 str -4837 } -4838 } -4839 } -4840 , -4841 { -4842 str -4843 : -4844 str -4845 , -4846 str -4847 : -4848 { -4849 str -4850 : -4851 str -4852 , -4853 str -4854 : -4855 num -4856 , -4857 str -4858 : -4859 { -4860 str -4861 : -4862 num -4863 , -4864 str -4865 : -4866 num -4867 } -4868 , -4869 str -4870 : -4871 str -4872 , -4873 str -4874 : -4875 num -4876 , -4877 str -4878 : -4879 { -4880 str -4881 : -4882 num -4883 , -4884 str -4885 : -4886 str -4887 , -4888 str -4889 : -4890 str -4891 , -4892 str -4893 : -4894 str -4895 , -4896 str -4897 : -4898 str -4899 , -4900 str -4901 : -4902 str -4903 } -4904 , -4905 str -4906 : -4907 { -4908 str -4909 : -4910 str -4911 , -4912 str -4913 : -4914 str -4915 } -4916 } -4917 } -4918 , -4919 { -4920 str -4921 : -4922 str -4923 , -4924 str -4925 : -4926 { -4927 str -4928 : -4929 str -4930 , -4931 str -4932 : -4933 num -4934 , -4935 str -4936 : -4937 { -4938 str -4939 : -4940 num -4941 , -4942 str -4943 : -4944 num -4945 } -4946 , -4947 str -4948 : -4949 str -4950 , -4951 str -4952 : -4953 num -4954 , -4955 str -4956 : -4957 { -4958 str -4959 : -4960 num -4961 , -4962 str -4963 : -4964 str -4965 , -4966 str -4967 : -4968 str -4969 , -4970 str -4971 : -4972 str -4973 , -4974 str -4975 : -4976 str -4977 , -4978 str -4979 : -4980 str -4981 } -4982 , -4983 str -4984 : -4985 { -4986 str -4987 : -4988 str -4989 , -4990 str -4991 : -4992 str -4993 } -4994 } -4995 } -4996 , -4997 { -4998 str -4999 : -5000 str -5001 , -5002 str -5003 : -5004 { -5005 str -5006 : -5007 str -5008 , -5009 str -5010 : -5011 num -5012 , -5013 str -5014 : -5015 { -5016 str -5017 : -5018 num -5019 , -5020 str -5021 : -5022 num -5023 } -5024 , -5025 str -5026 : -5027 str -5028 , -5029 str -5030 : -5031 num -5032 , -5033 str -5034 : -5035 { -5036 str -5037 : -5038 num -5039 , -5040 str -5041 : -5042 str -5043 , -5044 str -5045 : -5046 str -5047 , -5048 str -5049 : -5050 str -5051 , -5052 str -5053 : -5054 str -5055 , -5056 str -5057 : -5058 str -5059 } -5060 , -5061 str -5062 : -5063 { -5064 str -5065 : -5066 str -5067 , -5068 str -5069 : -5070 str -5071 } -5072 } -5073 } -5074 , -5075 { -5076 str -5077 : -5078 str -5079 , -5080 str -5081 : -5082 { -5083 str -5084 : -5085 str -5086 , -5087 str -5088 : -5089 num -5090 , -5091 str -5092 : -5093 { -5094 str -5095 : -5096 num -5097 , -5098 str -5099 : -5100 num -5101 } -5102 , -5103 str -5104 : -5105 str -5106 , -5107 str -5108 : -5109 num -5110 , -5111 str -5112 : -5113 { -5114 str -5115 : -5116 num -5117 , -5118 str -5119 : -5120 str -5121 , -5122 str -5123 : -5124 str -5125 , -5126 str -5127 : -5128 str -5129 , -5130 str -5131 : -5132 str -5133 , -5134 str -5135 : -5136 str -5137 } -5138 , -5139 str -5140 : -5141 { -5142 str -5143 : -5144 str -5145 , -5146 str -5147 : -5148 str -5149 } -5150 } -5151 } -5152 , -5153 { -5154 str -5155 : -5156 str -5157 , -5158 str -5159 : -5160 { -5161 str -5162 : -5163 str -5164 , -5165 str -5166 : -5167 num -5168 , -5169 str -5170 : -5171 { -5172 str -5173 : -5174 num -5175 , -5176 str -5177 : -5178 num -5179 } -5180 , -5181 str -5182 : -5183 str -5184 , -5185 str -5186 : -5187 num -5188 , -5189 str -5190 : -5191 { -5192 str -5193 : -5194 num -5195 , -5196 str -5197 : -5198 str -5199 , -5200 str -5201 : -5202 str -5203 , -5204 str -5205 : -5206 str -5207 , -5208 str -5209 : -5210 str -5211 , -5212 str -5213 : -5214 str -5215 } -5216 , -5217 str -5218 : -5219 { -5220 str -5221 : -5222 str -5223 , -5224 str -5225 : -5226 str -5227 } -5228 } -5229 } -5230 , -5231 { -5232 str -5233 : -5234 str -5235 , -5236 str -5237 : -5238 { -5239 str -5240 : -5241 str -5242 , -5243 str -5244 : -5245 num -5246 , -5247 str -5248 : -5249 { -5250 str -5251 : -5252 num -5253 , -5254 str -5255 : -5256 num -5257 } -5258 , -5259 str -5260 : -5261 str -5262 , -5263 str -5264 : -5265 num -5266 , -5267 str -5268 : -5269 { -5270 str -5271 : -5272 num -5273 , -5274 str -5275 : -5276 str -5277 , -5278 str -5279 : -5280 str -5281 , -5282 str -5283 : -5284 str -5285 , -5286 str -5287 : -5288 str -5289 , -5290 str -5291 : -5292 str -5293 } -5294 , -5295 str -5296 : -5297 { -5298 str -5299 : -5300 str -5301 , -5302 str -5303 : -5304 str -5305 } -5306 } -5307 } -5308 , -5309 { -5310 str -5311 : -5312 str -5313 , -5314 str -5315 : -5316 { -5317 str -5318 : -5319 str -5320 , -5321 str -5322 : -5323 num -5324 , -5325 str -5326 : -5327 { -5328 str -5329 : -5330 num -5331 , -5332 str -5333 : -5334 num -5335 } -5336 , -5337 str -5338 : -5339 str -5340 , -5341 str -5342 : -5343 num -5344 , -5345 str -5346 : -5347 { -5348 str -5349 : -5350 num -5351 , -5352 str -5353 : -5354 str -5355 , -5356 str -5357 : -5358 str -5359 , -5360 str -5361 : -5362 str -5363 , -5364 str -5365 : -5366 str -5367 , -5368 str -5369 : -5370 str -5371 } -5372 , -5373 str -5374 : -5375 { -5376 str -5377 : -5378 str -5379 , -5380 str -5381 : -5382 str -5383 } -5384 } -5385 } -5386 , -5387 { -5388 str -5389 : -5390 str -5391 , -5392 str -5393 : -5394 { -5395 str -5396 : -5397 str -5398 , -5399 str -5400 : -5401 num -5402 , -5403 str -5404 : -5405 { -5406 str -5407 : -5408 num -5409 , -5410 str -5411 : -5412 num -5413 } -5414 , -5415 str -5416 : -5417 str -5418 , -5419 str -5420 : -5421 num -5422 , -5423 str -5424 : -5425 { -5426 str -5427 : -5428 num -5429 , -5430 str -5431 : -5432 str -5433 , -5434 str -5435 : -5436 str -5437 , -5438 str -5439 : -5440 str -5441 , -5442 str -5443 : -5444 str -5445 , -5446 str -5447 : -5448 str -5449 } -5450 , -5451 str -5452 : -5453 { -5454 str -5455 : -5456 str -5457 , -5458 str -5459 : -5460 str -5461 } -5462 } -5463 } -5464 , -5465 { -5466 str -5467 : -5468 str -5469 , -5470 str -5471 : -5472 { -5473 str -5474 : -5475 str -5476 , -5477 str -5478 : -5479 num -5480 , -5481 str -5482 : -5483 { -5484 str -5485 : -5486 num -5487 , -5488 str -5489 : -5490 num -5491 } -5492 , -5493 str -5494 : -5495 str -5496 , -5497 str -5498 : -5499 num -5500 , -5501 str -5502 : -5503 { -5504 str -5505 : -5506 num -5507 , -5508 str -5509 : -5510 str -5511 , -5512 str -5513 : -5514 str -5515 , -5516 str -5517 : -5518 str -5519 , -5520 str -5521 : -5522 str -5523 , -5524 str -5525 : -5526 str -5527 } -5528 , -5529 str -5530 : -5531 { -5532 str -5533 : -5534 str -5535 , -5536 str -5537 : -5538 str -5539 } -5540 } -5541 } -5542 , -5543 { -5544 str -5545 : -5546 str -5547 , -5548 str -5549 : -5550 { -5551 str -5552 : -5553 str -5554 , -5555 str -5556 : -5557 num -5558 , -5559 str -5560 : -5561 { -5562 str -5563 : -5564 num -5565 , -5566 str -5567 : -5568 num -5569 } -5570 , -5571 str -5572 : -5573 str -5574 , -5575 str -5576 : -5577 num -5578 , -5579 str -5580 : -5581 { -5582 str -5583 : -5584 num -5585 , -5586 str -5587 : -5588 str -5589 , -5590 str -5591 : -5592 str -5593 , -5594 str -5595 : -5596 str -5597 , -5598 str -5599 : -5600 str -5601 , -5602 str -5603 : -5604 str -5605 } -5606 , -5607 str -5608 : -5609 { -5610 str -5611 : -5612 str -5613 , -5614 str -5615 : -5616 str -5617 } -5618 } -5619 } -5620 , -5621 { -5622 str -5623 : -5624 str -5625 , -5626 str -5627 : -5628 { -5629 str -5630 : -5631 str -5632 , -5633 str -5634 : -5635 num -5636 , -5637 str -5638 : -5639 { -5640 str -5641 : -5642 num -5643 , -5644 str -5645 : -5646 num -5647 } -5648 , -5649 str -5650 : -5651 str -5652 , -5653 str -5654 : -5655 num -5656 , -5657 str -5658 : -5659 { -5660 str -5661 : -5662 num -5663 , -5664 str -5665 : -5666 str -5667 , -5668 str -5669 : -5670 str -5671 , -5672 str -5673 : -5674 str -5675 , -5676 str -5677 : -5678 str -5679 , -5680 str -5681 : -5682 str -5683 } -5684 , -5685 str -5686 : -5687 { -5688 str -5689 : -5690 str -5691 , -5692 str -5693 : -5694 str -5695 } -5696 } -5697 } -5698 , -5699 { -5700 str -5701 : -5702 str -5703 , -5704 str -5705 : -5706 { -5707 str -5708 : -5709 str -5710 , -5711 str -5712 : -5713 num -5714 , -5715 str -5716 : -5717 { -5718 str -5719 : -5720 num -5721 , -5722 str -5723 : -5724 num -5725 } -5726 , -5727 str -5728 : -5729 str -5730 , -5731 str -5732 : -5733 num -5734 , -5735 str -5736 : -5737 { -5738 str -5739 : -5740 num -5741 , -5742 str -5743 : -5744 str -5745 , -5746 str -5747 : -5748 str -5749 , -5750 str -5751 : -5752 str -5753 , -5754 str -5755 : -5756 str -5757 , -5758 str -5759 : -5760 str -5761 } -5762 , -5763 str -5764 : -5765 { -5766 str -5767 : -5768 str -5769 , -5770 str -5771 : -5772 str -5773 } -5774 } -5775 } -5776 , -5777 { -5778 str -5779 : -5780 str -5781 , -5782 str -5783 : -5784 { -5785 str -5786 : -5787 str -5788 , -5789 str -5790 : -5791 num -5792 , -5793 str -5794 : -5795 { -5796 str -5797 : -5798 num -5799 , -5800 str -5801 : -5802 num -5803 } -5804 , -5805 str -5806 : -5807 str -5808 , -5809 str -5810 : -5811 num -5812 , -5813 str -5814 : -5815 { -5816 str -5817 : -5818 num -5819 , -5820 str -5821 : -5822 str -5823 , -5824 str -5825 : -5826 str -5827 , -5828 str -5829 : -5830 str -5831 , -5832 str -5833 : -5834 str -5835 , -5836 str -5837 : -5838 str -5839 } -5840 , -5841 str -5842 : -5843 { -5844 str -5845 : -5846 str -5847 , -5848 str -5849 : -5850 str -5851 } -5852 } -5853 } -5854 , -5855 { -5856 str -5857 : -5858 str -5859 , -5860 str -5861 : -5862 { -5863 str -5864 : -5865 str -5866 , -5867 str -5868 : -5869 num -5870 , -5871 str -5872 : -5873 { -5874 str -5875 : -5876 num -5877 , -5878 str -5879 : -5880 num -5881 } -5882 , -5883 str -5884 : -5885 str -5886 , -5887 str -5888 : -5889 num -5890 , -5891 str -5892 : -5893 { -5894 str -5895 : -5896 num -5897 , -5898 str -5899 : -5900 str -5901 , -5902 str -5903 : -5904 str -5905 , -5906 str -5907 : -5908 str -5909 , -5910 str -5911 : -5912 str -5913 , -5914 str -5915 : -5916 str -5917 } -5918 , -5919 str -5920 : -5921 { -5922 str -5923 : -5924 str -5925 , -5926 str -5927 : -5928 str -5929 } -5930 } -5931 } -5932 , -5933 { -5934 str -5935 : -5936 str -5937 , -5938 str -5939 : -5940 { -5941 str -5942 : -5943 str -5944 , -5945 str -5946 : -5947 num -5948 , -5949 str -5950 : -5951 { -5952 str -5953 : -5954 num -5955 , -5956 str -5957 : -5958 num -5959 } -5960 , -5961 str -5962 : -5963 str -5964 , -5965 str -5966 : -5967 num -5968 , -5969 str -5970 : -5971 { -5972 str -5973 : -5974 num -5975 , -5976 str -5977 : -5978 str -5979 , -5980 str -5981 : -5982 str -5983 , -5984 str -5985 : -5986 str -5987 , -5988 str -5989 : -5990 str -5991 , -5992 str -5993 : -5994 str -5995 } -5996 , -5997 str -5998 : -5999 { -6000 str -6001 : -6002 str -6003 , -6004 str -6005 : -6006 str -6007 } -6008 } -6009 } -6010 , -6011 { -6012 str -6013 : -6014 str -6015 , -6016 str -6017 : -6018 { -6019 str -6020 : -6021 str -6022 , -6023 str -6024 : -6025 num -6026 , -6027 str -6028 : -6029 { -6030 str -6031 : -6032 num -6033 , -6034 str -6035 : -6036 num -6037 } -6038 , -6039 str -6040 : -6041 str -6042 , -6043 str -6044 : -6045 num -6046 , -6047 str -6048 : -6049 { -6050 str -6051 : -6052 num -6053 , -6054 str -6055 : -6056 str -6057 , -6058 str -6059 : -6060 str -6061 , -6062 str -6063 : -6064 str -6065 , -6066 str -6067 : -6068 str -6069 , -6070 str -6071 : -6072 str -6073 } -6074 , -6075 str -6076 : -6077 { -6078 str -6079 : -6080 str -6081 , -6082 str -6083 : -6084 str -6085 } -6086 } -6087 } -6088 , -6089 { -6090 str -6091 : -6092 str -6093 , -6094 str -6095 : -6096 { -6097 str -6098 : -6099 str -6100 , -6101 str -6102 : -6103 num -6104 , -6105 str -6106 : -6107 { -6108 str -6109 : -6110 num -6111 , -6112 str -6113 : -6114 num -6115 } -6116 , -6117 str -6118 : -6119 str -6120 , -6121 str -6122 : -6123 num -6124 , -6125 str -6126 : -6127 { -6128 str -6129 : -6130 num -6131 , -6132 str -6133 : -6134 str -6135 , -6136 str -6137 : -6138 str -6139 , -6140 str -6141 : -6142 str -6143 , -6144 str -6145 : -6146 str -6147 , -6148 str -6149 : -6150 str -6151 } -6152 , -6153 str -6154 : -6155 { -6156 str -6157 : -6158 str -6159 , -6160 str -6161 : -6162 str -6163 } -6164 } -6165 } -6166 , -6167 { -6168 str -6169 : -6170 str -6171 , -6172 str -6173 : -6174 { -6175 str -6176 : -6177 str -6178 , -6179 str -6180 : -6181 num -6182 , -6183 str -6184 : -6185 { -6186 str -6187 : -6188 num -6189 , -6190 str -6191 : -6192 num -6193 } -6194 , -6195 str -6196 : -6197 str -6198 , -6199 str -6200 : -6201 num -6202 , -6203 str -6204 : -6205 { -6206 str -6207 : -6208 num -6209 , -6210 str -6211 : -6212 str -6213 , -6214 str -6215 : -6216 str -6217 , -6218 str -6219 : -6220 str -6221 , -6222 str -6223 : -6224 str -6225 , -6226 str -6227 : -6228 str -6229 } -6230 , -6231 str -6232 : -6233 { -6234 str -6235 : -6236 str -6237 , -6238 str -6239 : -6240 str -6241 } -6242 } -6243 } -6244 , -6245 { -6246 str -6247 : -6248 str -6249 , -6250 str -6251 : -6252 { -6253 str -6254 : -6255 str -6256 , -6257 str -6258 : -6259 num -6260 , -6261 str -6262 : -6263 { -6264 str -6265 : -6266 num -6267 , -6268 str -6269 : -6270 num -6271 } -6272 , -6273 str -6274 : -6275 str -6276 , -6277 str -6278 : -6279 num -6280 , -6281 str -6282 : -6283 { -6284 str -6285 : -6286 num -6287 , -6288 str -6289 : -6290 str -6291 , -6292 str -6293 : -6294 str -6295 , -6296 str -6297 : -6298 str -6299 , -6300 str -6301 : -6302 str -6303 , -6304 str -6305 : -6306 str -6307 } -6308 , -6309 str -6310 : -6311 { -6312 str -6313 : -6314 str -6315 , -6316 str -6317 : -6318 str -6319 } -6320 } -6321 } -6322 , -6323 { -6324 str -6325 : -6326 str -6327 , -6328 str -6329 : -6330 { -6331 str -6332 : -6333 str -6334 , -6335 str -6336 : -6337 num -6338 , -6339 str -6340 : -6341 { -6342 str -6343 : -6344 num -6345 , -6346 str -6347 : -6348 num -6349 } -6350 , -6351 str -6352 : -6353 str -6354 , -6355 str -6356 : -6357 num -6358 , -6359 str -6360 : -6361 { -6362 str -6363 : -6364 num -6365 , -6366 str -6367 : -6368 str -6369 , -6370 str -6371 : -6372 str -6373 , -6374 str -6375 : -6376 str -6377 , -6378 str -6379 : -6380 str -6381 , -6382 str -6383 : -6384 str -6385 } -6386 , -6387 str -6388 : -6389 { -6390 str -6391 : -6392 str -6393 , -6394 str -6395 : -6396 str -6397 } -6398 } -6399 } -6400 , -6401 { -6402 str -6403 : -6404 str -6405 , -6406 str -6407 : -6408 { -6409 str -6410 : -6411 str -6412 , -6413 str -6414 : -6415 num -6416 , -6417 str -6418 : -6419 { -6420 str -6421 : -6422 num -6423 , -6424 str -6425 : -6426 num -6427 } -6428 , -6429 str -6430 : -6431 str -6432 , -6433 str -6434 : -6435 num -6436 , -6437 str -6438 : -6439 { -6440 str -6441 : -6442 num -6443 , -6444 str -6445 : -6446 str -6447 , -6448 str -6449 : -6450 str -6451 , -6452 str -6453 : -6454 str -6455 , -6456 str -6457 : -6458 str -6459 , -6460 str -6461 : -6462 str -6463 } -6464 , -6465 str -6466 : -6467 { -6468 str -6469 : -6470 str -6471 , -6472 str -6473 : -6474 str -6475 } -6476 } -6477 } -6478 , -6479 { -6480 str -6481 : -6482 str -6483 , -6484 str -6485 : -6486 { -6487 str -6488 : -6489 str -6490 , -6491 str -6492 : -6493 num -6494 , -6495 str -6496 : -6497 { -6498 str -6499 : -6500 num -6501 , -6502 str -6503 : -6504 num -6505 } -6506 , -6507 str -6508 : -6509 str -6510 , -6511 str -6512 : -6513 num -6514 , -6515 str -6516 : -6517 { -6518 str -6519 : -6520 num -6521 , -6522 str -6523 : -6524 str -6525 , -6526 str -6527 : -6528 str -6529 , -6530 str -6531 : -6532 str -6533 , -6534 str -6535 : -6536 str -6537 , -6538 str -6539 : -6540 str -6541 } -6542 , -6543 str -6544 : -6545 { -6546 str -6547 : -6548 str -6549 , -6550 str -6551 : -6552 str -6553 } -6554 } -6555 } -6556 , -6557 { -6558 str -6559 : -6560 str -6561 , -6562 str -6563 : -6564 { -6565 str -6566 : -6567 str -6568 , -6569 str -6570 : -6571 num -6572 , -6573 str -6574 : -6575 { -6576 str -6577 : -6578 num -6579 , -6580 str -6581 : -6582 num -6583 } -6584 , -6585 str -6586 : -6587 str -6588 , -6589 str -6590 : -6591 num -6592 , -6593 str -6594 : -6595 { -6596 str -6597 : -6598 num -6599 , -6600 str -6601 : -6602 str -6603 , -6604 str -6605 : -6606 str -6607 , -6608 str -6609 : -6610 str -6611 , -6612 str -6613 : -6614 str -6615 , -6616 str -6617 : -6618 str -6619 } -6620 , -6621 str -6622 : -6623 { -6624 str -6625 : -6626 str -6627 , -6628 str -6629 : -6630 str -6631 } -6632 } -6633 } -6634 , -6635 { -6636 str -6637 : -6638 str -6639 , -6640 str -6641 : -6642 { -6643 str -6644 : -6645 str -6646 , -6647 str -6648 : -6649 num -6650 , -6651 str -6652 : -6653 { -6654 str -6655 : -6656 num -6657 , -6658 str -6659 : -6660 num -6661 } -6662 , -6663 str -6664 : -6665 str -6666 , -6667 str -6668 : -6669 num -6670 , -6671 str -6672 : -6673 { -6674 str -6675 : -6676 num -6677 , -6678 str -6679 : -6680 str -6681 , -6682 str -6683 : -6684 str -6685 , -6686 str -6687 : -6688 str -6689 , -6690 str -6691 : -6692 str -6693 , -6694 str -6695 : -6696 str -6697 } -6698 , -6699 str -6700 : -6701 { -6702 str -6703 : -6704 str -6705 , -6706 str -6707 : -6708 str -6709 } -6710 } -6711 } -6712 , -6713 { -6714 str -6715 : -6716 str -6717 , -6718 str -6719 : -6720 { -6721 str -6722 : -6723 str -6724 , -6725 str -6726 : -6727 num -6728 , -6729 str -6730 : -6731 { -6732 str -6733 : -6734 num -6735 , -6736 str -6737 : -6738 num -6739 } -6740 , -6741 str -6742 : -6743 str -6744 , -6745 str -6746 : -6747 num -6748 , -6749 str -6750 : -6751 { -6752 str -6753 : -6754 num -6755 , -6756 str -6757 : -6758 str -6759 , -6760 str -6761 : -6762 str -6763 , -6764 str -6765 : -6766 str -6767 , -6768 str -6769 : -6770 str -6771 , -6772 str -6773 : -6774 str -6775 } -6776 , -6777 str -6778 : -6779 { -6780 str -6781 : -6782 str -6783 , -6784 str -6785 : -6786 str -6787 } -6788 } -6789 } -6790 , -6791 { -6792 str -6793 : -6794 str -6795 , -6796 str -6797 : -6798 { -6799 str -6800 : -6801 str -6802 , -6803 str -6804 : -6805 num -6806 , -6807 str -6808 : -6809 { -6810 str -6811 : -6812 num -6813 , -6814 str -6815 : -6816 num -6817 } -6818 , -6819 str -6820 : -6821 str -6822 , -6823 str -6824 : -6825 num -6826 , -6827 str -6828 : -6829 { -6830 str -6831 : -6832 num -6833 , -6834 str -6835 : -6836 str -6837 , -6838 str -6839 : -6840 str -6841 , -6842 str -6843 : -6844 str -6845 , -6846 str -6847 : -6848 str -6849 , -6850 str -6851 : -6852 str -6853 } -6854 , -6855 str -6856 : -6857 { -6858 str -6859 : -6860 str -6861 , -6862 str -6863 : -6864 str -6865 } -6866 } -6867 } -6868 , -6869 { -6870 str -6871 : -6872 str -6873 , -6874 str -6875 : -6876 { -6877 str -6878 : -6879 str -6880 , -6881 str -6882 : -6883 num -6884 , -6885 str -6886 : -6887 { -6888 str -6889 : -6890 num -6891 , -6892 str -6893 : -6894 num -6895 } -6896 , -6897 str -6898 : -6899 str -6900 , -6901 str -6902 : -6903 num -6904 , -6905 str -6906 : -6907 { -6908 str -6909 : -6910 num -6911 , -6912 str -6913 : -6914 str -6915 , -6916 str -6917 : -6918 str -6919 , -6920 str -6921 : -6922 str -6923 , -6924 str -6925 : -6926 str -6927 , -6928 str -6929 : -6930 str -6931 } -6932 , -6933 str -6934 : -6935 { -6936 str -6937 : -6938 str -6939 , -6940 str -6941 : -6942 str -6943 } -6944 } -6945 } -6946 , -6947 { -6948 str -6949 : -6950 str -6951 , -6952 str -6953 : -6954 { -6955 str -6956 : -6957 str -6958 , -6959 str -6960 : -6961 num -6962 , -6963 str -6964 : -6965 { -6966 str -6967 : -6968 num -6969 , -6970 str -6971 : -6972 num -6973 } -6974 , -6975 str -6976 : -6977 str -6978 , -6979 str -6980 : -6981 num -6982 , -6983 str -6984 : -6985 { -6986 str -6987 : -6988 num -6989 , -6990 str -6991 : -6992 str -6993 , -6994 str -6995 : -6996 str -6997 , -6998 str -6999 : -7000 str -7001 , -7002 str -7003 : -7004 str -7005 , -7006 str -7007 : -7008 str -7009 } -7010 , -7011 str -7012 : -7013 { -7014 str -7015 : -7016 str -7017 , -7018 str -7019 : -7020 str -7021 } -7022 } -7023 } -7024 , -7025 { -7026 str -7027 : -7028 str -7029 , -7030 str -7031 : -7032 { -7033 str -7034 : -7035 str -7036 , -7037 str -7038 : -7039 num -7040 , -7041 str -7042 : -7043 { -7044 str -7045 : -7046 num -7047 , -7048 str -7049 : -7050 num -7051 } -7052 , -7053 str -7054 : -7055 str -7056 , -7057 str -7058 : -7059 num -7060 , -7061 str -7062 : -7063 { -7064 str -7065 : -7066 num -7067 , -7068 str -7069 : -7070 str -7071 , -7072 str -7073 : -7074 str -7075 , -7076 str -7077 : -7078 str -7079 , -7080 str -7081 : -7082 str -7083 , -7084 str -7085 : -7086 str -7087 } -7088 , -7089 str -7090 : -7091 { -7092 str -7093 : -7094 str -7095 , -7096 str -7097 : -7098 str -7099 } -7100 } -7101 } -7102 , -7103 { -7104 str -7105 : -7106 str -7107 , -7108 str -7109 : -7110 { -7111 str -7112 : -7113 str -7114 , -7115 str -7116 : -7117 num -7118 , -7119 str -7120 : -7121 { -7122 str -7123 : -7124 num -7125 , -7126 str -7127 : -7128 num -7129 } -7130 , -7131 str -7132 : -7133 str -7134 , -7135 str -7136 : -7137 num -7138 , -7139 str -7140 : -7141 { -7142 str -7143 : -7144 num -7145 , -7146 str -7147 : -7148 str -7149 , -7150 str -7151 : -7152 str -7153 , -7154 str -7155 : -7156 str -7157 , -7158 str -7159 : -7160 str -7161 , -7162 str -7163 : -7164 str -7165 } -7166 , -7167 str -7168 : -7169 { -7170 str -7171 : -7172 str -7173 , -7174 str -7175 : -7176 str -7177 } -7178 } -7179 } -7180 , -7181 { -7182 str -7183 : -7184 str -7185 , -7186 str -7187 : -7188 { -7189 str -7190 : -7191 str -7192 , -7193 str -7194 : -7195 num -7196 , -7197 str -7198 : -7199 { -7200 str -7201 : -7202 num -7203 , -7204 str -7205 : -7206 num -7207 } -7208 , -7209 str -7210 : -7211 str -7212 , -7213 str -7214 : -7215 num -7216 , -7217 str -7218 : -7219 { -7220 str -7221 : -7222 num -7223 , -7224 str -7225 : -7226 str -7227 , -7228 str -7229 : -7230 str -7231 , -7232 str -7233 : -7234 str -7235 , -7236 str -7237 : -7238 str -7239 , -7240 str -7241 : -7242 str -7243 } -7244 , -7245 str -7246 : -7247 { -7248 str -7249 : -7250 str -7251 , -7252 str -7253 : -7254 str -7255 } -7256 } -7257 } -7258 , -7259 { -7260 str -7261 : -7262 str -7263 , -7264 str -7265 : -7266 { -7267 str -7268 : -7269 str -7270 , -7271 str -7272 : -7273 num -7274 , -7275 str -7276 : -7277 { -7278 str -7279 : -7280 num -7281 , -7282 str -7283 : -7284 num -7285 } -7286 , -7287 str -7288 : -7289 str -7290 , -7291 str -7292 : -7293 num -7294 , -7295 str -7296 : -7297 { -7298 str -7299 : -7300 num -7301 , -7302 str -7303 : -7304 str -7305 , -7306 str -7307 : -7308 str -7309 , -7310 str -7311 : -7312 str -7313 , -7314 str -7315 : -7316 str -7317 , -7318 str -7319 : -7320 str -7321 } -7322 , -7323 str -7324 : -7325 { -7326 str -7327 : -7328 str -7329 , -7330 str -7331 : -7332 str -7333 } -7334 } -7335 } -7336 , -7337 { -7338 str -7339 : -7340 str -7341 , -7342 str -7343 : -7344 { -7345 str -7346 : -7347 str -7348 , -7349 str -7350 : -7351 num -7352 , -7353 str -7354 : -7355 { -7356 str -7357 : -7358 num -7359 , -7360 str -7361 : -7362 num -7363 } -7364 , -7365 str -7366 : -7367 str -7368 , -7369 str -7370 : -7371 num -7372 , -7373 str -7374 : -7375 { -7376 str -7377 : -7378 num -7379 , -7380 str -7381 : -7382 str -7383 , -7384 str -7385 : -7386 str -7387 , -7388 str -7389 : -7390 str -7391 , -7392 str -7393 : -7394 str -7395 , -7396 str -7397 : -7398 str -7399 } -7400 , -7401 str -7402 : -7403 { -7404 str -7405 : -7406 str -7407 , -7408 str -7409 : -7410 str -7411 } -7412 } -7413 } -7414 , -7415 { -7416 str -7417 : -7418 str -7419 , -7420 str -7421 : -7422 { -7423 str -7424 : -7425 str -7426 , -7427 str -7428 : -7429 num -7430 , -7431 str -7432 : -7433 { -7434 str -7435 : -7436 num -7437 , -7438 str -7439 : -7440 num -7441 } -7442 , -7443 str -7444 : -7445 str -7446 , -7447 str -7448 : -7449 num -7450 , -7451 str -7452 : -7453 { -7454 str -7455 : -7456 num -7457 , -7458 str -7459 : -7460 str -7461 , -7462 str -7463 : -7464 str -7465 , -7466 str -7467 : -7468 str -7469 , -7470 str -7471 : -7472 str -7473 , -7474 str -7475 : -7476 str -7477 } -7478 , -7479 str -7480 : -7481 { -7482 str -7483 : -7484 str -7485 , -7486 str -7487 : -7488 str -7489 } -7490 } -7491 } -7492 , -7493 { -7494 str -7495 : -7496 str -7497 , -7498 str -7499 : -7500 { -7501 str -7502 : -7503 str -7504 , -7505 str -7506 : -7507 num -7508 , -7509 str -7510 : -7511 { -7512 str -7513 : -7514 num -7515 , -7516 str -7517 : -7518 num -7519 } -7520 , -7521 str -7522 : -7523 str -7524 , -7525 str -7526 : -7527 num -7528 , -7529 str -7530 : -7531 { -7532 str -7533 : -7534 num -7535 , -7536 str -7537 : -7538 str -7539 , -7540 str -7541 : -7542 str -7543 , -7544 str -7545 : -7546 str -7547 , -7548 str -7549 : -7550 str -7551 , -7552 str -7553 : -7554 str -7555 } -7556 , -7557 str -7558 : -7559 { -7560 str -7561 : -7562 str -7563 , -7564 str -7565 : -7566 str -7567 } -7568 } -7569 } -7570 , -7571 { -7572 str -7573 : -7574 str -7575 , -7576 str -7577 : -7578 { -7579 str -7580 : -7581 str -7582 , -7583 str -7584 : -7585 num -7586 , -7587 str -7588 : -7589 { -7590 str -7591 : -7592 num -7593 , -7594 str -7595 : -7596 num -7597 } -7598 , -7599 str -7600 : -7601 str -7602 , -7603 str -7604 : -7605 num -7606 , -7607 str -7608 : -7609 { -7610 str -7611 : -7612 num -7613 , -7614 str -7615 : -7616 str -7617 , -7618 str -7619 : -7620 str -7621 , -7622 str -7623 : -7624 str -7625 , -7626 str -7627 : -7628 str -7629 , -7630 str -7631 : -7632 str -7633 } -7634 , -7635 str -7636 : -7637 { -7638 str -7639 : -7640 str -7641 , -7642 str -7643 : -7644 str -7645 } -7646 } -7647 } -7648 , -7649 { -7650 str -7651 : -7652 str -7653 , -7654 str -7655 : -7656 { -7657 str -7658 : -7659 str -7660 , -7661 str -7662 : -7663 num -7664 , -7665 str -7666 : -7667 { -7668 str -7669 : -7670 num -7671 , -7672 str -7673 : -7674 num -7675 } -7676 , -7677 str -7678 : -7679 str -7680 , -7681 str -7682 : -7683 num -7684 , -7685 str -7686 : -7687 { -7688 str -7689 : -7690 num -7691 , -7692 str -7693 : -7694 str -7695 , -7696 str -7697 : -7698 str -7699 , -7700 str -7701 : -7702 str -7703 , -7704 str -7705 : -7706 str -7707 , -7708 str -7709 : -7710 str -7711 } -7712 , -7713 str -7714 : -7715 { -7716 str -7717 : -7718 str -7719 , -7720 str -7721 : -7722 str -7723 } -7724 } -7725 } -7726 , -7727 { -7728 str -7729 : -7730 str -7731 , -7732 str -7733 : -7734 { -7735 str -7736 : -7737 str -7738 , -7739 str -7740 : -7741 num -7742 , -7743 str -7744 : -7745 { -7746 str -7747 : -7748 num -7749 , -7750 str -7751 : -7752 num -7753 } -7754 , -7755 str -7756 : -7757 str -7758 , -7759 str -7760 : -7761 num -7762 , -7763 str -7764 : -7765 { -7766 str -7767 : -7768 num -7769 , -7770 str -7771 : -7772 str -7773 , -7774 str -7775 : -7776 str -7777 , -7778 str -7779 : -7780 str -7781 , -7782 str -7783 : -7784 str -7785 , -7786 str -7787 : -7788 str -7789 } -7790 , -7791 str -7792 : -7793 { -7794 str -7795 : -7796 str -7797 , -7798 str -7799 : -7800 str -7801 } -7802 } -7803 } -7804 ] -7805 , -7806 str -7807 : -7808 { -7809 str -7810 : -7811 str -7812 , -7813 str -7814 : -7815 num -7816 , -7817 str -7818 : -7819 num -7820 } -7821 } \ No newline at end of file diff --git a/tests/cykjson_small_token.csv b/tests/cykjson_small_token.csv deleted file mode 100644 index 9d48b3b..0000000 --- a/tests/cykjson_small_token.csv +++ /dev/null @@ -1,801 +0,0 @@ -1 { -2 str -3 : -4 [ -5 { -6 str -7 : -8 str -9 , -10 str -11 : -12 { -13 str -14 : -15 str -16 , -17 str -18 : -19 num -20 , -21 str -22 : -23 { -24 str -25 : -26 num -27 , -28 str -29 : -30 num -31 } -32 , -33 str -34 : -35 str -36 , -37 str -38 : -39 num -40 , -41 str -42 : -43 { -44 str -45 : -46 num -47 , -48 str -49 : -50 str -51 , -52 str -53 : -54 str -55 , -56 str -57 : -58 str -59 , -60 str -61 : -62 str -63 , -64 str -65 : -66 str -67 } -68 , -69 str -70 : -71 { -72 str -73 : -74 str -75 , -76 str -77 : -78 str -79 } -80 } -81 } -82 , -83 { -84 str -85 : -86 str -87 , -88 str -89 : -90 { -91 str -92 : -93 str -94 , -95 str -96 : -97 num -98 , -99 str -100 : -101 { -102 str -103 : -104 num -105 , -106 str -107 : -108 num -109 } -110 , -111 str -112 : -113 str -114 , -115 str -116 : -117 num -118 , -119 str -120 : -121 { -122 str -123 : -124 num -125 , -126 str -127 : -128 str -129 , -130 str -131 : -132 str -133 , -134 str -135 : -136 str -137 , -138 str -139 : -140 str -141 , -142 str -143 : -144 str -145 } -146 , -147 str -148 : -149 { -150 str -151 : -152 str -153 , -154 str -155 : -156 str -157 } -158 } -159 } -160 , -161 { -162 str -163 : -164 str -165 , -166 str -167 : -168 { -169 str -170 : -171 str -172 , -173 str -174 : -175 num -176 , -177 str -178 : -179 { -180 str -181 : -182 num -183 , -184 str -185 : -186 num -187 } -188 , -189 str -190 : -191 str -192 , -193 str -194 : -195 num -196 , -197 str -198 : -199 { -200 str -201 : -202 num -203 , -204 str -205 : -206 str -207 , -208 str -209 : -210 str -211 , -212 str -213 : -214 str -215 , -216 str -217 : -218 str -219 , -220 str -221 : -222 str -223 } -224 , -225 str -226 : -227 { -228 str -229 : -230 str -231 , -232 str -233 : -234 str -235 } -236 } -237 } -238 , -239 { -240 str -241 : -242 str -243 , -244 str -245 : -246 { -247 str -248 : -249 str -250 , -251 str -252 : -253 num -254 , -255 str -256 : -257 { -258 str -259 : -260 num -261 , -262 str -263 : -264 num -265 } -266 , -267 str -268 : -269 str -270 , -271 str -272 : -273 num -274 , -275 str -276 : -277 { -278 str -279 : -280 num -281 , -282 str -283 : -284 str -285 , -286 str -287 : -288 str -289 , -290 str -291 : -292 str -293 , -294 str -295 : -296 str -297 , -298 str -299 : -300 str -301 } -302 , -303 str -304 : -305 { -306 str -307 : -308 str -309 , -310 str -311 : -312 str -313 } -314 } -315 } -316 , -317 { -318 str -319 : -320 str -321 , -322 str -323 : -324 { -325 str -326 : -327 str -328 , -329 str -330 : -331 num -332 , -333 str -334 : -335 { -336 str -337 : -338 num -339 , -340 str -341 : -342 num -343 } -344 , -345 str -346 : -347 str -348 , -349 str -350 : -351 num -352 , -353 str -354 : -355 { -356 str -357 : -358 num -359 , -360 str -361 : -362 str -363 , -364 str -365 : -366 str -367 , -368 str -369 : -370 str -371 , -372 str -373 : -374 str -375 , -376 str -377 : -378 str -379 } -380 , -381 str -382 : -383 { -384 str -385 : -386 str -387 , -388 str -389 : -390 str -391 } -392 } -393 } -394 , -395 { -396 str -397 : -398 str -399 , -400 str -401 : -402 { -403 str -404 : -405 str -406 , -407 str -408 : -409 num -410 , -411 str -412 : -413 { -414 str -415 : -416 num -417 , -418 str -419 : -420 num -421 } -422 , -423 str -424 : -425 str -426 , -427 str -428 : -429 num -430 , -431 str -432 : -433 { -434 str -435 : -436 num -437 , -438 str -439 : -440 str -441 , -442 str -443 : -444 str -445 , -446 str -447 : -448 str -449 , -450 str -451 : -452 str -453 , -454 str -455 : -456 str -457 } -458 , -459 str -460 : -461 { -462 str -463 : -464 str -465 , -466 str -467 : -468 str -469 } -470 } -471 } -472 , -473 { -474 str -475 : -476 str -477 , -478 str -479 : -480 { -481 str -482 : -483 str -484 , -485 str -486 : -487 num -488 , -489 str -490 : -491 { -492 str -493 : -494 num -495 , -496 str -497 : -498 num -499 } -500 , -501 str -502 : -503 str -504 , -505 str -506 : -507 num -508 , -509 str -510 : -511 { -512 str -513 : -514 num -515 , -516 str -517 : -518 str -519 , -520 str -521 : -522 str -523 , -524 str -525 : -526 str -527 , -528 str -529 : -530 str -531 , -532 str -533 : -534 str -535 } -536 , -537 str -538 : -539 { -540 str -541 : -542 str -543 , -544 str -545 : -546 str -547 } -548 } -549 } -550 , -551 { -552 str -553 : -554 str -555 , -556 str -557 : -558 { -559 str -560 : -561 str -562 , -563 str -564 : -565 num -566 , -567 str -568 : -569 { -570 str -571 : -572 num -573 , -574 str -575 : -576 num -577 } -578 , -579 str -580 : -581 str -582 , -583 str -584 : -585 num -586 , -587 str -588 : -589 { -590 str -591 : -592 num -593 , -594 str -595 : -596 str -597 , -598 str -599 : -600 str -601 , -602 str -603 : -604 str -605 , -606 str -607 : -608 str -609 , -610 str -611 : -612 str -613 } -614 , -615 str -616 : -617 { -618 str -619 : -620 str -621 , -622 str -623 : -624 str -625 } -626 } -627 } -628 , -629 { -630 str -631 : -632 str -633 , -634 str -635 : -636 { -637 str -638 : -639 str -640 , -641 str -642 : -643 num -644 , -645 str -646 : -647 { -648 str -649 : -650 num -651 , -652 str -653 : -654 num -655 } -656 , -657 str -658 : -659 str -660 , -661 str -662 : -663 num -664 , -665 str -666 : -667 { -668 str -669 : -670 num -671 , -672 str -673 : -674 str -675 , -676 str -677 : -678 str -679 , -680 str -681 : -682 str -683 , -684 str -685 : -686 str -687 , -688 str -689 : -690 str -691 } -692 , -693 str -694 : -695 { -696 str -697 : -698 str -699 , -700 str -701 : -702 str -703 } -704 } -705 } -706 , -707 { -708 str -709 : -710 str -711 , -712 str -713 : -714 { -715 str -716 : -717 str -718 , -719 str -720 : -721 num -722 , -723 str -724 : -725 { -726 str -727 : -728 num -729 , -730 str -731 : -732 num -733 } -734 , -735 str -736 : -737 str -738 , -739 str -740 : -741 num -742 , -743 str -744 : -745 { -746 str -747 : -748 num -749 , -750 str -751 : -752 str -753 , -754 str -755 : -756 str -757 , -758 str -759 : -760 str -761 , -762 str -763 : -764 str -765 , -766 str -767 : -768 str -769 } -770 , -771 str -772 : -773 { -774 str -775 : -776 str -777 , -778 str -779 : -780 str -781 } -782 } -783 } -784 ] -785 , -786 str -787 : -788 { -789 str -790 : -791 str -792 , -793 str -794 : -795 num -796 , -797 str -798 : -799 num -800 } -801 } \ No newline at end of file diff --git a/tests/datatypes.egg b/tests/datatypes.egg deleted file mode 100644 index 9f5cfa8..0000000 --- a/tests/datatypes.egg +++ /dev/null @@ -1,11 +0,0 @@ -(datatype* - (Math - (Add Math Math) - (Sum MathVec) - (B Bool)) - (sort MathVec (Vec Math)) - (Bool - (True) - (False))) - -(let expr (Add (Sum (vec-of (B (True)) (B (False)))) (B (True)))) diff --git a/tests/delete.egg b/tests/delete.egg deleted file mode 100644 index 15fd4c8..0000000 --- a/tests/delete.egg +++ /dev/null @@ -1,6 +0,0 @@ -(function foo (i64) i64) -(set (foo 1) 7) -(check (= (foo 1) 7)) -(delete (foo 1)) -(rule ((= x (foo 1))) ((panic "foo 1 was there!"))) -(run 1) \ No newline at end of file diff --git a/tests/eggcc-extraction.egg b/tests/eggcc-extraction.egg deleted file mode 100644 index 2edb8c4..0000000 --- a/tests/eggcc-extraction.egg +++ /dev/null @@ -1,1711 +0,0 @@ - -(datatype Literal) -(datatype Expr) -(datatype Operand) -(datatype Body) - -(sort VecOperandBase (Vec Operand)) -(datatype VecOperand (VO VecOperandBase)) - -(sort VecVecOperandBase (Vec VecOperand)) -(datatype VecVecOperand (VVO VecVecOperandBase)) - -;; Type -(datatype Type - (IntT) - (BoolT) - (FloatT) - (CharT) - (PointerT Type)) -(datatype EffectType - (Bril Type) - (PrintState)) -(sort FuncSigs (Vec EffectType)) -(datatype OptionType - (SomeType Type) - (NoneType)) -;; Literal -(function Num (i64) Literal) -(function Float (f64) Literal) -(function Char (String) Literal) -(function Bool (bool) Literal) - -;; Expr -(datatype ConstOps (const)) -(function Const (Type ConstOps Literal) Expr) -;; Call may return multiple values but at most one of them -;; is a value type, which is stored in OptionType. -;; The last fields denotes how many return values it have -;; Finally, we assume if call ever returns a value, -;; it has to be the first one. -(function Call (OptionType String VecOperand i64) Expr :cost 1000) ; TODO: fix cost model -(function badd (Type Operand Operand) Expr) -(function bsub (Type Operand Operand) Expr) -(function bmul (Type Operand Operand) Expr) -(function bfmul (Type Operand Operand) Expr) -(function bdiv (Type Operand Operand) Expr) -(function beq (Type Operand Operand) Expr) -(function blt (Type Operand Operand) Expr) -(function bgt (Type Operand Operand) Expr) -(function ble (Type Operand Operand) Expr) -(function bge (Type Operand Operand) Expr) -(function bnot (Type Operand Operand) Expr) -(function band (Type Operand Operand) Expr) -(function bor (Type Operand Operand) Expr) -(function PRINT (Operand Operand) Expr) - -;; Operand -(function Arg (i64) Operand) -(function Node (Body) Operand) -(function Project (i64 Body) Operand) - -;; Body -(function PureOp (Expr) Body) -;; branching -;; predicate (outside switch), inputs (outside switch), -;; and for each branch a vector of outputs -(function Gamma (Operand VecOperand VecVecOperand) Body) -;; loops -;; predicate (inside loop), inputs (outside loop), outputs (inside loop) -(function Theta (Operand VecOperand VecOperand) Body) -;; A body can also just be a VecOperand for convenience -;; This has no corresponding node in rust, it can be -;; removed during translation -(function OperandGroup (VecOperand) Body) - -(datatype Function - ;; name input types output types body - (Func String FuncSigs FuncSigs VecOperand)) - - -;; procedure f(n): -;; i = 0 -;; ans = 0 -;; do: -;; ans += i*5; -;; i += 1 -;; while(i < n); -;; return ansm - -;; ;; inputs: [n] -; (Project 0 -; (Theta -; ; i n -; (lt (Arg 1) (Arg 2)) ;; pred -; (vec-of ;; inputs -; (Node (PureOp (Const 0))) ;; accumulator -; (Node (PureOp (Const 0))) ;; loop var -; (Arg 0) ;; n -; ) -; (vec-of ;; outputs -; (Node (PureOp (add (Arg 0) ;; ans -; (Node (PureOp (mul -; (Arg 1) ;; i -; (Node (PureOp (Const 5))))))))) ;; ans = i*5 -; (Node (PureOp (add (Arg 1) (Node (PureOp (Const 1)))))) ;; i += 1 -; (Arg 2) ;; n -; )) -; ) - - - -(ruleset fast-analyses) - - (function VecOperand-get (VecOperand i64) Operand) - (rule ((VO x) (> (vec-length x) 0)) - ((union (VecOperand-get (VO x) 0) (vec-get x 0))) - :ruleset fast-analyses) - (rule ((VecOperand-get (VO x) j) - (= i (+ j 1)) (< i (vec-length x))) - ((union (VecOperand-get (VO x) i) (vec-get x i))) - :ruleset fast-analyses) - - (function VecOperand-length (VecOperand) i64) - (rule ((VO x)) - ((set (VecOperand-length (VO x)) (vec-length x))) - :ruleset fast-analyses) - - - (function VecVecOperand-get (VecVecOperand i64) VecOperand) - (rule ((VVO x) (> (vec-length x) 0)) - ((union (VecVecOperand-get (VVO x) 0) (vec-get x 0))) - :ruleset fast-analyses) - (rule ((VecVecOperand-get (VVO x) j) - (= i (+ j 1)) (< i (vec-length x))) - ((union (VecVecOperand-get (VVO x) i) (vec-get x i))) - :ruleset fast-analyses) - - (function VecVecOperand-length (VecVecOperand) i64) - (rule ((VVO x)) - ((set (VecVecOperand-length (VVO x)) (vec-length x))) - :ruleset fast-analyses) - - - (relation Expr-is-pure (Expr)) - (relation Operand-is-pure (Operand)) - (relation Body-is-pure (Body)) - (relation VecOperand-is-pure (VecOperand)) - (function VecOperand-pure-prefix (VecOperand) i64 :merge (max old new)) - (relation VecVecOperand-is-pure (VecVecOperand)) - (function VecVecOperand-pure-prefix (VecVecOperand) i64 :merge (max old new)) - (relation Function-is-pure (Function)) - - - (rule ((= f (Const ty ops lit))) - ((Expr-is-pure f)) - :ruleset fast-analyses) - - (rule ((= f (Call ty name args n-outs)) - (Function-is-pure (Func name input-types output-types body))) - ((Expr-is-pure f)) - :ruleset fast-analyses) - - - (rule ((= f (badd type e1 e2)) - (Operand-is-pure e1) - (Operand-is-pure e2)) - ((Expr-is-pure f)) - :ruleset fast-analyses) - - - (rule ((= f (bsub type e1 e2)) - (Operand-is-pure e1) - (Operand-is-pure e2)) - ((Expr-is-pure f)) - :ruleset fast-analyses) - - - (rule ((= f (bmul type e1 e2)) - (Operand-is-pure e1) - (Operand-is-pure e2)) - ((Expr-is-pure f)) - :ruleset fast-analyses) - - - (rule ((= f (bdiv type e1 e2)) - (Operand-is-pure e1) - (Operand-is-pure e2)) - ((Expr-is-pure f)) - :ruleset fast-analyses) - - - (rule ((= f (blt type e1 e2)) - (Operand-is-pure e1) - (Operand-is-pure e2)) - ((Expr-is-pure f)) - :ruleset fast-analyses) - - - (rule ((= f (Arg x))) - ((Operand-is-pure f)) - :ruleset fast-analyses) - (rule ((= f (Node body)) - (Body-is-pure body)) - ((Operand-is-pure f)) - :ruleset fast-analyses) - (rule ((= f (Project i body)) - (Body-is-pure body)) - ((Operand-is-pure f)) - :ruleset fast-analyses) - - - (rule ((= f (PureOp e)) - (Expr-is-pure e)) - ((Body-is-pure f)) - :ruleset fast-analyses) - (rule ((= f (Gamma pred inputs outputs)) - (Operand-is-pure pred) - (VecOperand-is-pure inputs) - (VecVecOperand-is-pure outputs)) - ((Body-is-pure f)) - :ruleset fast-analyses) - (rule ((= f (Theta pred inputs outputs)) - (Operand-is-pure pred) - (VecOperand-is-pure inputs) - (VecOperand-is-pure outputs)) - ((Body-is-pure f)) - :ruleset fast-analyses) - (rule ((= f (OperandGroup vec)) - (VecOperand-is-pure vec)) - ((Body-is-pure f)) - :ruleset fast-analyses) - - - (rule ((= f (VO vec))) - ((set (VecOperand-pure-prefix f) 0)) - :ruleset fast-analyses) - (rule ((= i (VecOperand-pure-prefix f)) - (< i (VecOperand-length f)) - (Operand-is-pure (VecOperand-get f i))) - ((set (VecOperand-pure-prefix f) (+ i 1))) - :ruleset fast-analyses) - (rule ((= (VecOperand-length f) (VecOperand-pure-prefix f))) - ((VecOperand-is-pure f)) - :ruleset fast-analyses) - - - (rule ((= f (VVO vec))) - ((set (VecVecOperand-pure-prefix f) 0)) - :ruleset fast-analyses) - (rule ((= i (VecVecOperand-pure-prefix f)) - (< i (VecVecOperand-length f)) - (VecOperand-is-pure (VecVecOperand-get f i))) - ((set (VecVecOperand-pure-prefix f) (+ i 1))) - :ruleset fast-analyses) - (rule ((= (VecVecOperand-length f) (VecVecOperand-pure-prefix f))) - ((VecVecOperand-is-pure f)) - :ruleset fast-analyses) - - - (rule ((= f (Func name input-types output-types body)) - (VecOperand-is-pure body)) - ((Function-is-pure f)) - :ruleset fast-analyses) - - - (relation Body-contains-Expr (Body i64 Expr)) - (relation Body-contains-Operand (Body i64 Operand)) - (relation Body-contains-Body (Body i64 Body)) - - - (rule ((= f (PureOp e))) - ((Body-contains-Expr f 0 e)) - :ruleset fast-analyses) - ; A Gamma only contains its outputs - (rule ((= f (Gamma pred inputs outputs)) - (= outputs-i (VecVecOperand-get outputs i)) - (= x (VecOperand-get outputs-i j))) - ((Body-contains-Operand f i x)) - :ruleset fast-analyses) - ; A Theta contains its pred and outputs - (rule ((= f (Theta pred inputs outputs))) - ((Body-contains-Operand f -1 pred)) - :ruleset fast-analyses) - (rule ((= f (Theta pred inputs outputs)) - (= x (VecOperand-get outputs i))) - ((Body-contains-Operand f i x)) - :ruleset fast-analyses) - (rule ((= f (OperandGroup vec)) - (= x (VecOperand-get vec i))) - ((Body-contains-Operand f i x)) - :ruleset fast-analyses) - - - (rule ((Body-contains-Body f i (PureOp e))) - ((Body-contains-Expr f i e)) - :ruleset fast-analyses) - ; A Gamma's pred and inputs are in the outer context - (rule ((Body-contains-Body f i (Gamma pred inputs outputs))) - ((Body-contains-Operand f i pred)) - :ruleset fast-analyses) - (rule ((Body-contains-Body f i (Gamma pred inputs outputs)) - (= x (VecOperand-get inputs any))) - ((Body-contains-Operand f i x)) - :ruleset fast-analyses) - ; A Theta's inputs are in the outer context - (rule ((Body-contains-Body f i (Theta pred inputs outputs)) - (= x (VecOperand-get inputs any))) - ((Body-contains-Operand f i x)) - :ruleset fast-analyses) - (rule ((Body-contains-Body f i (OperandGroup vec)) - (= x (VecOperand-get vec any))) - ((Body-contains-Operand f i x)) - :ruleset fast-analyses) - - - (rule ((Body-contains-Expr f i (Call ty name args n-outs)) - (= x (VecOperand-get args any))) - ((Body-contains-Operand f i x)) - :ruleset fast-analyses) - (rule ((Body-contains-Expr f i (PRINT e1 e2))) - ((Body-contains-Operand f i e1) - (Body-contains-Operand f i e2)) - :ruleset fast-analyses) - - - (rule ((Body-contains-Expr f i (badd type e1 e2))) - ((Body-contains-Operand f i e1) - (Body-contains-Operand f i e2)) - :ruleset fast-analyses) - - - (rule ((Body-contains-Expr f i (bsub type e1 e2))) - ((Body-contains-Operand f i e1) - (Body-contains-Operand f i e2)) - :ruleset fast-analyses) - - - (rule ((Body-contains-Expr f i (bmul type e1 e2))) - ((Body-contains-Operand f i e1) - (Body-contains-Operand f i e2)) - :ruleset fast-analyses) - - - (rule ((Body-contains-Expr f i (bdiv type e1 e2))) - ((Body-contains-Operand f i e1) - (Body-contains-Operand f i e2)) - :ruleset fast-analyses) - - - (rule ((Body-contains-Expr f i (blt type e1 e2))) - ((Body-contains-Operand f i e1) - (Body-contains-Operand f i e2)) - :ruleset fast-analyses) - - - (rule ((Body-contains-Operand f i (Node body))) - ((Body-contains-Body f i body)) - :ruleset fast-analyses) - (rule ((Body-contains-Operand f i (Project i body))) - ((Body-contains-Body f i body)) - :ruleset fast-analyses) - -(ruleset subst) (ruleset shift) - - (relation can-subst-Expr-beneath (Body Expr Expr)) - (relation can-subst-Operand-beneath (Body Operand Operand)) - (relation can-subst-Body-beneath (Body Body Body)) - (relation can-subst-VecVecOperand-beneath (Body VecVecOperand VecVecOperand)) - (relation can-subst-VecOperand-beneath (Body VecOperand VecOperand)) - - ;; Base case 'do the substitution' rules - (rule ((can-subst-Operand-beneath above from to) - (= above (Theta from inputs outputs))) - ((union above (Theta to inputs outputs))) - :ruleset subst) - (rule ((can-subst-VecOperand-beneath above from to) - (= above (Theta pred inputs from))) - ((union above (Theta pred inputs to))) - :ruleset subst) - (rule ((can-subst-Operand-beneath above pred-from pred-to) - (can-subst-VecOperand-beneath above outputs-from outputs-to) - (= above (Theta pred-from inputs outputs-from))) - ((union above (Theta pred-from inputs outputs-to))) - :ruleset subst) - (rule ((can-subst-VecVecOperand-beneath above from to) - (= above (Gamma pred inputs from))) - ((union above (Gamma pred inputs to))) - :ruleset subst) - (rule ((can-subst-VecOperand-beneath above from to) - (= above (OperandGroup from))) - ((union above (OperandGroup to))) - :ruleset subst) - - ;; Learn can-subst-Operand-beneath - (rule ((can-subst-Body-beneath above from to) - (= new-from (Node from))) - ((can-subst-Operand-beneath above new-from (Node to))) - :ruleset subst) - (rule ((can-subst-Body-beneath above from to) - (= new-from (Project i from))) - ((can-subst-Operand-beneath above new-from (Project i to))) - :ruleset subst) - - ;; Learn can-subst-body-beneath - (rule ((can-subst-Expr-beneath above from to) - (= new-from (PureOp from))) - ((can-subst-Body-beneath above new-from (PureOp to))) - :ruleset subst) - ;; Propagates up same context (Gamma: pred & inputs, Theta: inputs) - ;; rtjoa: Is it sound to propagate up outputs if we renumber args? - (rule ((can-subst-Operand-beneath above from to) - (= new-from (Gamma from inputs outputs))) - ((can-subst-Body-beneath above new-from (Gamma to inputs outputs))) - :ruleset subst) - (rule ((can-subst-VecOperand-beneath above from to) - (= new-from (Gamma pred from outputs))) - ((can-subst-Body-beneath above new-from (Gamma pred to outputs))) - :ruleset subst) - (rule ((can-subst-VecOperand-beneath above from to) - (= new-from (Theta pred from outputs))) - ((can-subst-Body-beneath above new-from (Theta pred to outputs))) - :ruleset subst) - (rule ((can-subst-VecOperand-beneath above from to) - (= new-from (OperandGroup from))) - ((can-subst-Body-beneath above new-from (OperandGroup to))) - :ruleset subst) - - - (rule ((can-subst-VecOperand-beneath above from to) - (= new-from (Call ty f from n-outs))) - ((can-subst-Expr-beneath above new-from (Call ty f to n-outs))) - :ruleset subst) - - (rule ((can-subst-Operand-beneath above from to) - (= new-from (badd type from e2))) - ((can-subst-Expr-beneath above new-from (badd type to e2))) - :ruleset subst) - (rule ((can-subst-Operand-beneath above from to) - (= new-from (badd type e1 from))) - ((can-subst-Expr-beneath above new-from (badd type e1 to))) - :ruleset subst) - - - (rule ((can-subst-Operand-beneath above from to) - (= new-from (bsub type from e2))) - ((can-subst-Expr-beneath above new-from (bsub type to e2))) - :ruleset subst) - (rule ((can-subst-Operand-beneath above from to) - (= new-from (bsub type e1 from))) - ((can-subst-Expr-beneath above new-from (bsub type e1 to))) - :ruleset subst) - - - (rule ((can-subst-Operand-beneath above from to) - (= new-from (bmul type from e2))) - ((can-subst-Expr-beneath above new-from (bmul type to e2))) - :ruleset subst) - (rule ((can-subst-Operand-beneath above from to) - (= new-from (bmul type e1 from))) - ((can-subst-Expr-beneath above new-from (bmul type e1 to))) - :ruleset subst) - - - (rule ((can-subst-Operand-beneath above from to) - (= new-from (bdiv type from e2))) - ((can-subst-Expr-beneath above new-from (bdiv type to e2))) - :ruleset subst) - (rule ((can-subst-Operand-beneath above from to) - (= new-from (bdiv type e1 from))) - ((can-subst-Expr-beneath above new-from (bdiv type e1 to))) - :ruleset subst) - - - (rule ((can-subst-Operand-beneath above from to) - (= new-from (blt type from e2))) - ((can-subst-Expr-beneath above new-from (blt type to e2))) - :ruleset subst) - (rule ((can-subst-Operand-beneath above from to) - (= new-from (blt type e1 from))) - ((can-subst-Expr-beneath above new-from (blt type e1 to))) - :ruleset subst) - - - (rule ((can-subst-Operand-beneath above from to) - (= from (VecOperand-get (VO vec) i))) - ((can-subst-VecOperand-beneath - above - (VO vec) - (VO (vec-set vec i to)))) - :ruleset subst) - - (rule ((can-subst-VecOperand-beneath above from to) - (= from (VecVecOperand-get (VVO vec) i))) - ((can-subst-VecVecOperand-beneath - above - (VVO vec) - (VVO (vec-set vec i to)))) - :ruleset subst) -(function SubstExpr (Expr i64 Operand) Expr :unextractable) -(function SubstOperand (Operand i64 Operand) Operand :unextractable) -(function SubstBody (Body i64 Operand) Body :unextractable) -(function SubstVecOperand (VecOperand i64 Operand) VecOperand :unextractable) -(function SubstVecVecOperand (VecVecOperand i64 Operand) VecVecOperand :unextractable) - - (rewrite - (SubstExpr (badd ty a b) x0 x1) - (badd - ty - (SubstOperand a x0 x1) - (SubstOperand b x0 x1)) - :ruleset subst) - - - (rewrite - (SubstExpr (bsub ty a b) x0 x1) - (bsub - ty - (SubstOperand a x0 x1) - (SubstOperand b x0 x1)) - :ruleset subst) - - - (rewrite - (SubstExpr (bmul ty a b) x0 x1) - (bmul - ty - (SubstOperand a x0 x1) - (SubstOperand b x0 x1)) - :ruleset subst) - - - (rewrite - (SubstExpr (bdiv ty a b) x0 x1) - (bdiv - ty - (SubstOperand a x0 x1) - (SubstOperand b x0 x1)) - :ruleset subst) - - - (rewrite - (SubstExpr (blt ty a b) x0 x1) - (blt - ty - (SubstOperand a x0 x1) - (SubstOperand b x0 x1)) - :ruleset subst) - - - (rewrite - (SubstExpr (Const ty ops lit) x0 x1) - (Const ty ops lit) - :ruleset subst) - (rewrite - (SubstExpr (Call ty f args n-outs) x0 x1) - (Call ty f (SubstVecOperand args x0 x1) n-outs) - :ruleset subst) - (rewrite - (SubstExpr (PRINT a b) x0 x1) - (PRINT (SubstOperand a x0 x1) (SubstOperand b x0 x1)) - :ruleset subst) - - (rewrite (SubstOperand (Arg x) x v) v :ruleset subst) - (rule ((= f (SubstOperand (Arg y) x v)) (!= y x)) - ((union f (Arg y))) :ruleset subst) - - (rewrite - (SubstOperand (Node b) x0 x1) - (Node (SubstBody b x0 x1)) - :ruleset subst) - (rewrite - (SubstOperand (Project i b) x0 x1) - (Project i (SubstBody b x0 x1)) - :ruleset subst) - - (rewrite - (SubstBody (PureOp e) x0 x1) - (PureOp (SubstExpr e x0 x1)) - :ruleset subst) - ;; Don't cross regions, so so we shift into the inputs but not outputs - ;; A Gamma's pred is on the outside, so it's affected, but not a Theta's - (rewrite - (SubstBody (Gamma pred inputs outputs) x0 x1) - (Gamma - (SubstOperand pred x0 x1) - (SubstVecOperand inputs x0 x1) - outputs) - :ruleset subst) - (rewrite - (SubstBody (Theta pred inputs outputs) x0 x1) - (Theta pred (SubstVecOperand inputs x0 x1) outputs) - :ruleset subst) - - (function SubstVecOperand-helper (VecOperand i64 Operand i64) VecOperand) - (rewrite - (SubstVecOperand vec x0 x1) - (SubstVecOperand-helper vec x0 x1 0) - :ruleset subst) - (rule - ((= f (SubstVecOperand-helper (VO vec) x0 x1 i)) - (< i (vec-length vec))) - ((union - (SubstVecOperand-helper (VO vec) x0 x1 i) - (SubstVecOperand-helper - (VO (vec-set vec i (SubstOperand (vec-get vec i) x0 x1))) - x0 x1 (+ i 1)))) - :ruleset subst) - (rule - ((= f (SubstVecOperand-helper (VO vec) x0 x1 i)) - (= i (vec-length vec))) - ((union - (SubstVecOperand-helper (VO vec) x0 x1 i) - (VO vec))) - :ruleset subst) - - (function SubstVecVecOperand-helper (VecVecOperand i64 Operand i64) VecVecOperand) - (rewrite - (SubstVecVecOperand vec x0 x1) - (SubstVecVecOperand-helper vec x0 x1 0) - :ruleset subst) - (rule - ((= f (SubstVecVecOperand-helper (VVO vec) x0 x1 i)) - (< i (vec-length vec))) - ((union - (SubstVecVecOperand-helper (VVO vec) x0 x1 i) - (SubstVecVecOperand-helper - (VVO (vec-set vec i (SubstVecOperand (vec-get vec i) x0 x1))) - x0 x1 (+ i 1)))) - :ruleset subst) - (rule - ((= f (SubstVecVecOperand-helper (VVO vec) x0 x1 i)) - (= i (vec-length vec))) - ((union - (SubstVecVecOperand-helper (VVO vec) x0 x1 i) - (VVO vec))) - :ruleset subst) -(function SubstExprAll (Expr VecOperand) Expr :unextractable) -(function SubstOperandAll (Operand VecOperand) Operand :unextractable) -(function SubstBodyAll (Body VecOperand) Body :unextractable) -(function SubstVecOperandAll (VecOperand VecOperand) VecOperand :unextractable) -(function SubstVecVecOperandAll (VecVecOperand VecOperand) VecVecOperand :unextractable) - - (rewrite - (SubstExprAll (badd ty a b) x0) - (badd - ty - (SubstOperandAll a x0) - (SubstOperandAll b x0)) - :ruleset subst) - - - (rewrite - (SubstExprAll (bsub ty a b) x0) - (bsub - ty - (SubstOperandAll a x0) - (SubstOperandAll b x0)) - :ruleset subst) - - - (rewrite - (SubstExprAll (bmul ty a b) x0) - (bmul - ty - (SubstOperandAll a x0) - (SubstOperandAll b x0)) - :ruleset subst) - - - (rewrite - (SubstExprAll (bdiv ty a b) x0) - (bdiv - ty - (SubstOperandAll a x0) - (SubstOperandAll b x0)) - :ruleset subst) - - - (rewrite - (SubstExprAll (blt ty a b) x0) - (blt - ty - (SubstOperandAll a x0) - (SubstOperandAll b x0)) - :ruleset subst) - - - (rewrite - (SubstExprAll (Const ty ops lit) x0) - (Const ty ops lit) - :ruleset subst) - (rewrite - (SubstExprAll (Call ty f args n-outs) x0) - (Call ty f (SubstVecOperandAll args x0) n-outs) - :ruleset subst) - (rewrite - (SubstExprAll (PRINT a b) x0) - (PRINT (SubstOperandAll a x0) (SubstOperandAll b x0)) - :ruleset subst) - - (rule ((= f (SubstOperandAll (Arg x) (VO ops))) - (< x (vec-length ops))) - ((union f (vec-get ops x))) :ruleset subst) - - (rewrite - (SubstOperandAll (Node b) x0) - (Node (SubstBodyAll b x0)) - :ruleset subst) - (rewrite - (SubstOperandAll (Project i b) x0) - (Project i (SubstBodyAll b x0)) - :ruleset subst) - - (rewrite - (SubstBodyAll (PureOp e) x0) - (PureOp (SubstExprAll e x0)) - :ruleset subst) - ;; Don't cross regions, so so we shift into the inputs but not outputs - ;; A Gamma's pred is on the outside, so it's affected, but not a Theta's - (rewrite - (SubstBodyAll (Gamma pred inputs outputs) x0) - (Gamma - (SubstOperandAll pred x0) - (SubstVecOperandAll inputs x0) - outputs) - :ruleset subst) - (rewrite - (SubstBodyAll (Theta pred inputs outputs) x0) - (Theta pred (SubstVecOperandAll inputs x0) outputs) - :ruleset subst) - - (function SubstVecOperandAll-helper (VecOperand VecOperand i64) VecOperand) - (rewrite - (SubstVecOperandAll vec x0) - (SubstVecOperandAll-helper vec x0 0) - :ruleset subst) - (rule - ((= f (SubstVecOperandAll-helper (VO vec) x0 i)) - (< i (vec-length vec))) - ((union - (SubstVecOperandAll-helper (VO vec) x0 i) - (SubstVecOperandAll-helper - (VO (vec-set vec i (SubstOperandAll (vec-get vec i) x0))) - x0 (+ i 1)))) - :ruleset subst) - (rule - ((= f (SubstVecOperandAll-helper (VO vec) x0 i)) - (= i (vec-length vec))) - ((union - (SubstVecOperandAll-helper (VO vec) x0 i) - (VO vec))) - :ruleset subst) - - (function SubstVecVecOperandAll-helper (VecVecOperand VecOperand i64) VecVecOperand) - (rewrite - (SubstVecVecOperandAll vec x0) - (SubstVecVecOperandAll-helper vec x0 0) - :ruleset subst) - (rule - ((= f (SubstVecVecOperandAll-helper (VVO vec) x0 i)) - (< i (vec-length vec))) - ((union - (SubstVecVecOperandAll-helper (VVO vec) x0 i) - (SubstVecVecOperandAll-helper - (VVO (vec-set vec i (SubstVecOperandAll (vec-get vec i) x0))) - x0 (+ i 1)))) - :ruleset subst) - (rule - ((= f (SubstVecVecOperandAll-helper (VVO vec) x0 i)) - (= i (vec-length vec))) - ((union - (SubstVecVecOperandAll-helper (VVO vec) x0 i) - (VVO vec))) - :ruleset subst) -(function ShiftExpr (Expr i64 i64) Expr :unextractable) -(function ShiftOperand (Operand i64 i64) Operand :unextractable) -(function ShiftBody (Body i64 i64) Body :unextractable) -(function ShiftVecOperand (VecOperand i64 i64) VecOperand :unextractable) -(function ShiftVecVecOperand (VecVecOperand i64 i64) VecVecOperand :unextractable) - - (rewrite - (ShiftExpr (badd ty a b) x0 x1) - (badd - ty - (ShiftOperand a x0 x1) - (ShiftOperand b x0 x1)) - :ruleset shift) - - - (rewrite - (ShiftExpr (bsub ty a b) x0 x1) - (bsub - ty - (ShiftOperand a x0 x1) - (ShiftOperand b x0 x1)) - :ruleset shift) - - - (rewrite - (ShiftExpr (bmul ty a b) x0 x1) - (bmul - ty - (ShiftOperand a x0 x1) - (ShiftOperand b x0 x1)) - :ruleset shift) - - - (rewrite - (ShiftExpr (bdiv ty a b) x0 x1) - (bdiv - ty - (ShiftOperand a x0 x1) - (ShiftOperand b x0 x1)) - :ruleset shift) - - - (rewrite - (ShiftExpr (blt ty a b) x0 x1) - (blt - ty - (ShiftOperand a x0 x1) - (ShiftOperand b x0 x1)) - :ruleset shift) - - - (rewrite - (ShiftExpr (Const ty ops lit) x0 x1) - (Const ty ops lit) - :ruleset shift) - (rewrite - (ShiftExpr (Call ty f args n-outs) x0 x1) - (Call ty f (ShiftVecOperand args x0 x1) n-outs) - :ruleset shift) - (rewrite - (ShiftExpr (PRINT a b) x0 x1) - (PRINT (ShiftOperand a x0 x1) (ShiftOperand b x0 x1)) - :ruleset shift) - - (rule ((= f (ShiftOperand (Arg x) last-unshifted amt)) (<= x last-unshifted)) - ((union f (Arg x))) :ruleset shift) - (rule ((= f (ShiftOperand (Arg x) last-unshifted amt)) (> x last-unshifted)) - ((union f (Arg (+ x amt)))) :ruleset shift) - - (rewrite - (ShiftOperand (Node b) x0 x1) - (Node (ShiftBody b x0 x1)) - :ruleset shift) - (rewrite - (ShiftOperand (Project i b) x0 x1) - (Project i (ShiftBody b x0 x1)) - :ruleset shift) - - (rewrite - (ShiftBody (PureOp e) x0 x1) - (PureOp (ShiftExpr e x0 x1)) - :ruleset shift) - ;; Don't cross regions, so so we shift into the inputs but not outputs - ;; A Gamma's pred is on the outside, so it's affected, but not a Theta's - (rewrite - (ShiftBody (Gamma pred inputs outputs) x0 x1) - (Gamma - (ShiftOperand pred x0 x1) - (ShiftVecOperand inputs x0 x1) - outputs) - :ruleset shift) - (rewrite - (ShiftBody (Theta pred inputs outputs) x0 x1) - (Theta pred (ShiftVecOperand inputs x0 x1) outputs) - :ruleset shift) - - (function ShiftVecOperand-helper (VecOperand i64 i64 i64) VecOperand) - (rewrite - (ShiftVecOperand vec x0 x1) - (ShiftVecOperand-helper vec x0 x1 0) - :ruleset shift) - (rule - ((= f (ShiftVecOperand-helper (VO vec) x0 x1 i)) - (< i (vec-length vec))) - ((union - (ShiftVecOperand-helper (VO vec) x0 x1 i) - (ShiftVecOperand-helper - (VO (vec-set vec i (ShiftOperand (vec-get vec i) x0 x1))) - x0 x1 (+ i 1)))) - :ruleset shift) - (rule - ((= f (ShiftVecOperand-helper (VO vec) x0 x1 i)) - (= i (vec-length vec))) - ((union - (ShiftVecOperand-helper (VO vec) x0 x1 i) - (VO vec))) - :ruleset shift) - - (function ShiftVecVecOperand-helper (VecVecOperand i64 i64 i64) VecVecOperand) - (rewrite - (ShiftVecVecOperand vec x0 x1) - (ShiftVecVecOperand-helper vec x0 x1 0) - :ruleset shift) - (rule - ((= f (ShiftVecVecOperand-helper (VVO vec) x0 x1 i)) - (< i (vec-length vec))) - ((union - (ShiftVecVecOperand-helper (VVO vec) x0 x1 i) - (ShiftVecVecOperand-helper - (VVO (vec-set vec i (ShiftVecOperand (vec-get vec i) x0 x1))) - x0 x1 (+ i 1)))) - :ruleset shift) - (rule - ((= f (ShiftVecVecOperand-helper (VVO vec) x0 x1 i)) - (= i (vec-length vec))) - ((union - (ShiftVecVecOperand-helper (VVO vec) x0 x1 i) - (VVO vec))) - :ruleset shift) -;; #################################### -;; implementation of PassThroughArguments -;; Creates a vec of arguments -;; (vec-of (Arg 0) (Arg 1) ...) with length i -(function PassThroughArguments (i64) VecOperand :unextractable) - - - -;; (how many arguments to generate, vector so far) -(function PassThroughArgumentsHelper (i64 VecOperand) VecOperand :unextractable) - -(rewrite (PassThroughArguments i) - (PassThroughArgumentsHelper i (VO (vec-of))) - :ruleset subst) - -(rule ((= lhs (PassThroughArgumentsHelper i (VO rest))) - (< (vec-length rest) i)) - ((union lhs - (PassThroughArgumentsHelper i - (VO (vec-push rest (Arg (vec-length rest))))))) - :ruleset subst) - -(rule ((= lhs (PassThroughArgumentsHelper i (VO rest))) - (= (vec-length rest) i)) - ((union lhs (VO rest))) - :ruleset subst) - - - -;; Project each argument out of a body -(function BodyToVecOperand (i64 Body) VecOperand :unextractable) -;; current index, body length, body, and vector so far -(function BodyToVecOperandHelper (i64 i64 Body VecOperandBase) VecOperand :unextractable) - -(rewrite (BodyToVecOperand body-len body) - (BodyToVecOperandHelper 0 body-len body (vec-of))) -(rule - ((= helper (BodyToVecOperandHelper index body-len body so-far)) - (< index body-len)) - ((union helper - (BodyToVecOperandHelper (+ index 1) body-len body - (vec-push so-far - (Project index body))))) - :ruleset subst) - -(rule - ((= helper (BodyToVecOperandHelper index body-len body so-far)) - (= index body-len)) - ((union helper (VO so-far))) - :ruleset subst) - - - -;; constant_fold.rs adds most constant folding operations -;; this file is for special cases - - -;; eliminate gamma nodes for true and false cases -(rule ((= gamma - ;; gamma predicate is true - (Gamma (Node (PureOp (Const (BoolT) (const) (Bool true)))) - inputs - (VVO outputs)))) - ( - ;; replace use of the gamma with - ;; the true case - (union - gamma - (OperandGroup - (SubstVecOperandAll - (vec-get outputs 1) - inputs))))) - - - -(rule ((= gamma - ;; gamma predicate is false - (Gamma (Node (PureOp (Const (BoolT) (const) (Bool false)))) - inputs - (VVO outputs)))) - ( - ;; replace use of the gamma with - ;; the false case - (union - gamma - (OperandGroup - (SubstVecOperandAll (vec-get outputs 0) inputs))))) - -;; Eliminate theta -;; Unroll one layer and get rid of loop -(rule ((= theta - ;; gamma predicate is false - (Theta (Node (PureOp (Const (BoolT) (const) (Bool false)))) - (VO inputs) - (VO outputs)))) - ((let after-one-iter (SubstVecOperandAll (VO outputs) (VO inputs))) - (union theta - (OperandGroup after-one-iter)))) - - - - - -(rewrite (badd output_type - (Node (PureOp (Const ty2 (const) (Num n1)))) - (Node (PureOp (Const ty3 (const) (Num n2))))) - (Const output_type (const) (Num (+ n1 n2)))) -(rewrite (bsub output_type - (Node (PureOp (Const ty2 (const) (Num n1)))) - (Node (PureOp (Const ty3 (const) (Num n2))))) - (Const output_type (const) (Num (- n1 n2)))) -(rewrite (bmul output_type - (Node (PureOp (Const ty2 (const) (Num n1)))) - (Node (PureOp (Const ty3 (const) (Num n2))))) - (Const output_type (const) (Num (* n1 n2)))) -(rewrite (bdiv output_type - (Node (PureOp (Const ty2 (const) (Num n1)))) - (Node (PureOp (Const ty3 (const) (Num n2))))) - (Const output_type (const) (Num (/ n1 n2)))) -(rewrite (blt output_type - (Node (PureOp (Const ty2 (const) (Num n1)))) - (Node (PureOp (Const ty3 (const) (Num n2))))) - (Const output_type (const) (Bool (bool-< n1 n2)))) -(sort TermAndCost) -(function Smaller (TermAndCost TermAndCost) TermAndCost) - -;; manual, bottom-up extraction of terms using this function -(function ExtractedExpr (Expr) TermAndCost - :merge (Smaller old new)) -;; Store a term and its cost for this type -(function ExprAndCost (Expr i64) TermAndCost) - -;; Perform smaller using the next two rules -(rule ((= lhs (Smaller (ExprAndCost t1 cost1) - (ExprAndCost t2 cost2))) - (<= cost1 cost2)) - ((union lhs (ExprAndCost t1 cost1))) - :ruleset fast-analyses) - -(rule ((= lhs (Smaller (ExprAndCost t1 cost1) - (ExprAndCost t2 cost2))) - (> cost1 cost2)) - ((union lhs (ExprAndCost t2 cost2))) - :ruleset fast-analyses) - - -;; manual, bottom-up extraction of terms using this function -(function ExtractedOperand (Operand) TermAndCost - :merge (Smaller old new)) -;; Store a term and its cost for this type -(function OperandAndCost (Operand i64) TermAndCost) - -;; Perform smaller using the next two rules -(rule ((= lhs (Smaller (OperandAndCost t1 cost1) - (OperandAndCost t2 cost2))) - (<= cost1 cost2)) - ((union lhs (OperandAndCost t1 cost1))) - :ruleset fast-analyses) - -(rule ((= lhs (Smaller (OperandAndCost t1 cost1) - (OperandAndCost t2 cost2))) - (> cost1 cost2)) - ((union lhs (OperandAndCost t2 cost2))) - :ruleset fast-analyses) - - -;; manual, bottom-up extraction of terms using this function -(function ExtractedBody (Body) TermAndCost - :merge (Smaller old new)) -;; Store a term and its cost for this type -(function BodyAndCost (Body i64) TermAndCost) - -;; Perform smaller using the next two rules -(rule ((= lhs (Smaller (BodyAndCost t1 cost1) - (BodyAndCost t2 cost2))) - (<= cost1 cost2)) - ((union lhs (BodyAndCost t1 cost1))) - :ruleset fast-analyses) - -(rule ((= lhs (Smaller (BodyAndCost t1 cost1) - (BodyAndCost t2 cost2))) - (> cost1 cost2)) - ((union lhs (BodyAndCost t2 cost2))) - :ruleset fast-analyses) - - -;; manual, bottom-up extraction of terms using this function -(function ExtractedVecOperand (VecOperand) TermAndCost - :merge (Smaller old new)) -;; Store a term and its cost for this type -(function VecOperandAndCost (VecOperand i64) TermAndCost) - -;; Perform smaller using the next two rules -(rule ((= lhs (Smaller (VecOperandAndCost t1 cost1) - (VecOperandAndCost t2 cost2))) - (<= cost1 cost2)) - ((union lhs (VecOperandAndCost t1 cost1))) - :ruleset fast-analyses) - -(rule ((= lhs (Smaller (VecOperandAndCost t1 cost1) - (VecOperandAndCost t2 cost2))) - (> cost1 cost2)) - ((union lhs (VecOperandAndCost t2 cost2))) - :ruleset fast-analyses) - - -;; manual, bottom-up extraction of terms using this function -(function ExtractedVecVecOperand (VecVecOperand) TermAndCost - :merge (Smaller old new)) -;; Store a term and its cost for this type -(function VecVecOperandAndCost (VecVecOperand i64) TermAndCost) - -;; Perform smaller using the next two rules -(rule ((= lhs (Smaller (VecVecOperandAndCost t1 cost1) - (VecVecOperandAndCost t2 cost2))) - (<= cost1 cost2)) - ((union lhs (VecVecOperandAndCost t1 cost1))) - :ruleset fast-analyses) - -(rule ((= lhs (Smaller (VecVecOperandAndCost t1 cost1) - (VecVecOperandAndCost t2 cost2))) - (> cost1 cost2)) - ((union lhs (VecVecOperandAndCost t2 cost2))) - :ruleset fast-analyses) - - -(rule ((= lhs (badd ty a b)) - (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) - (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) - ((set (ExtractedExpr lhs) - (ExprAndCost (badd ty expr1 expr2) - (+ 1 (+ cost1 cost2))))) - :ruleset fast-analyses) - - -(rule ((= lhs (bsub ty a b)) - (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) - (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) - ((set (ExtractedExpr lhs) - (ExprAndCost (bsub ty expr1 expr2) - (+ 1 (+ cost1 cost2))))) - :ruleset fast-analyses) - - -(rule ((= lhs (bmul ty a b)) - (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) - (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) - ((set (ExtractedExpr lhs) - (ExprAndCost (bmul ty expr1 expr2) - (+ 1 (+ cost1 cost2))))) - :ruleset fast-analyses) - - -(rule ((= lhs (bdiv ty a b)) - (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) - (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) - ((set (ExtractedExpr lhs) - (ExprAndCost (bdiv ty expr1 expr2) - (+ 1 (+ cost1 cost2))))) - :ruleset fast-analyses) - - -(rule ((= lhs (blt ty a b)) - (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) - (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) - ((set (ExtractedExpr lhs) - (ExprAndCost (blt ty expr1 expr2) - (+ 1 (+ cost1 cost2))))) - :ruleset fast-analyses) - - -(rule ((= lhs (PRINT a b)) - (= (OperandAndCost expr1 cost1) (ExtractedOperand a)) - (= (OperandAndCost expr2 cost2) (ExtractedOperand b))) - ((set (ExtractedExpr lhs) - (ExprAndCost (PRINT expr1 expr2) - (+ 1 (+ cost1 cost2))))) - :ruleset fast-analyses) - -;; TODO fix this HACK -;; this is how we get an empty vector of vectors in egglog because of -;; typechecking bug in egglog https://github.com/egraphs-good/egglog/issues/113 -(let empty-vvo - (vec-pop (vec-of (VO (vec-of))))) - - -(function ExtractedVecOperandHelper (VecOperand i64) TermAndCost :merge (Smaller old new)) - -;; base case: extract nothing -(rule - ((VO vec)) - ((set (ExtractedVecOperandHelper (VO vec) 0) - (VecOperandAndCost (VO (vec-of)) 0))) - :ruleset fast-analyses) - -;; extract one more thing -(rule - ((= (VecOperandAndCost (VO current) current-cost) - (ExtractedVecOperandHelper (VO vec) index)) - (< index (vec-length vec)) - (= (ExtractedOperand (VecOperand-get (VO vec) index)) (OperandAndCost expr expr-cost))) - ((set (ExtractedVecOperandHelper (VO vec) (+ index 1)) - (VecOperandAndCost - (VO (vec-push current expr)) - (+ current-cost expr-cost)))) - :ruleset fast-analyses) - - - -;; finished extracting, create result -(rule - ((= result - (ExtractedVecOperandHelper (VO vec) index)) - ;; at the end - (= index (vec-length vec))) - ((set (ExtractedVecOperand (VO vec)) - result)) - :ruleset fast-analyses) - - -(function ExtractedVecVecOperandHelper (VecVecOperand i64) TermAndCost :merge (Smaller old new)) - -;; base case: extract nothing -(rule - ((VVO vec)) - ((set (ExtractedVecVecOperandHelper (VVO vec) 0) - (VecVecOperandAndCost (VVO empty-vvo) 0))) - :ruleset fast-analyses) - -;; extract one more thing -(rule - ((= (VecVecOperandAndCost (VVO current) current-cost) - (ExtractedVecVecOperandHelper (VVO vec) index)) - (< index (vec-length vec)) - (= (ExtractedVecOperand (VecVecOperand-get (VVO vec) index)) (VecOperandAndCost expr expr-cost))) - ((set (ExtractedVecVecOperandHelper (VVO vec) (+ index 1)) - (VecVecOperandAndCost - (VVO (vec-push current expr)) - (+ current-cost expr-cost)))) - :ruleset fast-analyses) - - - -;; finished extracting, create result -(rule - ((= result - (ExtractedVecVecOperandHelper (VVO vec) index)) - ;; at the end - (= index (vec-length vec))) - ((set (ExtractedVecVecOperand (VVO vec)) - result)) - :ruleset fast-analyses) - - -;; Constant gets cost of 1 -(rule - ((= lhs (Const ty ops lit))) - ((set (ExtractedExpr lhs) (ExprAndCost lhs 1))) - :ruleset fast-analyses) - -;; arg gets cost of 1 -(rule - ((= lhs (Arg index))) - ((set (ExtractedOperand lhs) (OperandAndCost lhs 1))) - :ruleset fast-analyses) - - -;; PureOp doesn't add cost -(rule - ((= lhs (PureOp expr)) - (= (ExprAndCost expr-extracted expr-cost) - (ExtractedExpr expr))) - ((set (ExtractedBody lhs) (BodyAndCost (PureOp expr-extracted) expr-cost))) - :ruleset fast-analyses) - -;; Nor does Node -(rule - ((= lhs (Node body)) - (= (BodyAndCost body-extracted body-cost) - (ExtractedBody body))) - ((set (ExtractedOperand lhs) (OperandAndCost (Node body-extracted) body-cost))) - :ruleset fast-analyses) - -;; Theta gets a cost of 1 for now -(rule - ((= lhs (Theta pred inputs outputs)) - (= (OperandAndCost pred-extracted pred-cost) - (ExtractedOperand pred)) - (= (VecOperandAndCost inputs-extracted inputs-cost) - (ExtractedVecOperand inputs)) - (= (VecOperandAndCost outputs-extracted outputs-cost) - (ExtractedVecOperand outputs))) - ((set (ExtractedBody lhs) - (BodyAndCost - (Theta pred-extracted inputs-extracted outputs-extracted) - (+ 1 (+ pred-cost (+ inputs-cost outputs-cost)))))) - :ruleset fast-analyses) - -;; Gamma gets a cost of 1 for now -(rule - ((= lhs (Gamma pred inputs outputs)) - (= (OperandAndCost pred-extracted pred-cost) - (ExtractedOperand pred)) - (= (VecOperandAndCost inputs-extracted inputs-cost) - (ExtractedVecOperand inputs)) - (= (VecVecOperandAndCost outputs-extracted outputs-cost) - (ExtractedVecVecOperand outputs))) - ((set (ExtractedBody lhs) - (BodyAndCost - (Gamma pred-extracted inputs-extracted outputs-extracted) - (+ 1 (+ pred-cost (+ inputs-cost outputs-cost)))))) - :ruleset fast-analyses) - - -;; Project is also free -(rule ((= lhs (Project index body)) - (= (BodyAndCost body-extracted body-cost) - (ExtractedBody body))) - ((set (ExtractedOperand lhs) - (OperandAndCost (Project index body-extracted) body-cost))) - :ruleset fast-analyses) - - - -;; If a theta passes along argument, -;; can extract the input instead. -(rule ((= lhs (Project index loop)) - (= loop (Theta pred inputs outputs)) - (= (VecOperand-get outputs index) (Arg index)) - (= passedthrough (ExtractedOperand (VecOperand-get inputs index))) - ) - ((set (ExtractedOperand lhs) passedthrough)) - :ruleset fast-analyses) - -;; If a gamma passes along an argument in both branches, -;; extract the input instead. -(rule ((= lhs (Project index loop)) - (= loop (Gamma pred inputs outputs)) - (= outputs (VVO outputs-inner)) - (= 2 (vec-length outputs-inner)) - (= outputs0 (VecVecOperand-get outputs 0)) - (= outputs1 (VecVecOperand-get outputs 1)) - (= (VecOperand-get outputs0 index) (Arg index)) - (= (VecOperand-get outputs1 index) (Arg index)) - (= passedthrough (ExtractedOperand (VecOperand-get inputs index)))) - ((set (ExtractedOperand lhs) passedthrough)) - :ruleset fast-analyses) - - -;; if we reach a new context, union -(rule ((= theta (Theta pred inputs outputs)) - (= (BodyAndCost extracted cost) - (ExtractedBody theta))) - ((union theta extracted)) - :ruleset fast-analyses) -(rule ((= gamma (Gamma pred inputs outputs)) - (= (BodyAndCost extracted cost) - (ExtractedBody gamma))) - ((union gamma extracted)) - :ruleset fast-analyses) - - -;; if we reach the function at the top level, union -(rule ((= func (Func name intypes outtypes body)) - (= (VecOperandAndCost extracted cost) - (ExtractedVecOperand body))) - ((union func - (Func name intypes outtypes extracted))) - :ruleset fast-analyses) - -;; if a && b: -;; A -;; else: -;; B -;; ---------- -;; if a: -;; if b: -;; A -;; else: -;; B -;; else: -;; B -(rule ((= gamma (Gamma (Node (PureOp (band BoolT a b))) (VO inputs) (VVO outputs))) - (= (vec-length outputs) 2) - (= (vec-get outputs 1) (VO A)) - (= (vec-get outputs 0) (VO B)) - (= args (vec-length inputs)) - (= rets (vec-length B))) - ((let inner (Gamma (Arg args) ; we pass b as an extra argument to the outer gamma - (PassThroughArguments args) - (VVO (vec-of (VO B) - (VO A))))) - (union gamma (Gamma a - (VO (vec-push inputs b)) ; pass b as an extra argument - (VVO (vec-of (VO B) - (BodyToVecOperand rets inner))))))) - -;; if a || b: -;; A -;; else: -;; B -;; ----------- -;; if a: -;; A -;; else: -;; if b: -;; A -;; else: -;; B -(rule ((= gamma (Gamma (Node (PureOp (bor BoolT a b))) (VO inputs) (VVO outputs))) - (= (vec-length outputs) 2) - (= (vec-get outputs 1) (VO A)) - (= (vec-get outputs 0) (VO B)) - (= args (vec-length inputs)) - (= rets (vec-length B))) - ((let inner (Gamma (Arg args) ; we pass b as an extra argument to the outer gamma - (PassThroughArguments args) - (VVO (vec-of (VO B) - (VO A))))) - (union gamma (Gamma a - (VO (vec-push inputs b)) ; pass b as an extra argument - (VVO (vec-of (BodyToVecOperand rets inner) - (VO A))))))) - -;; if a: -;; A -;; else: -;; A -;; ------ -;; A -(rule ((= gamma (Gamma condition inputs (VVO outputs))) - (= (vec-length outputs) 2) - (= (vec-get outputs 0) (vec-get outputs 1))) - ((union gamma (OperandGroup (SubstVecOperandAll (vec-get outputs 0) inputs))))) - - -;; unroll loops -(rule ((= theta (Theta pred (VO inputs) (VO outputs)))) - ;; arguments body - ((let after-one-iter - (SubstVecOperandAll (VO outputs) (VO inputs))) - ;; (vec-of (Arg 0) (Arg 1) ...) - (let pass-through (PassThroughArguments (vec-length outputs))) - (union theta - (Gamma - (SubstOperandAll pred after-one-iter) - after-one-iter - (VVO - (vec-of - ;; in the false case, we are done - pass-through - ;; otherwise do the rest of the loop - (BodyToVecOperand - (vec-length outputs) - (Theta pred pass-through - (VO outputs))))))))) - - - -(datatype Interval - (BoolI bool bool) - (IntI i64 i64) - (interval-intersect Interval Interval) - (interval-union Interval Interval)) - - -(rewrite (interval-intersect (IntI la ha) (IntI lb hb)) - (IntI (max la lb) (min ha hb))) -(rewrite (interval-union (IntI la ha) (IntI lb hb)) - (IntI (min la lb) (max ha hb))) - -(rewrite (interval-intersect (BoolI la ha) (BoolI lb hb)) - (BoolI (or la lb) (and ha hb))) -(rewrite (interval-union (BoolI la ha) (BoolI lb hb)) - (BoolI (and la lb) (or ha hb))) - -(function ival (Operand) Interval - :merge (interval-intersect old new)) - -; context-specific intervals (because Args need to have interval analysis but are not globally unique) -(function context-ival (Operand Body) Interval - :merge (interval-intersect old new)) - -(rule ((= lhs (Node (PureOp (Const (BoolT) (const) (Bool b)))))) - ((set (ival lhs) (BoolI b b)))) - -(rule ((= lhs (Node (PureOp (Const (IntT) (const) (Num n)))))) - ((set (ival lhs) (IntI n n)))) - - -; < a b interval (< ha lb) (< la hb) -(rule ((= lhs (Node (PureOp (blt (BoolT) a b)))) - (= (IntI la ha) (ival a)) - (= (IntI lb hb) (ival b))) - ((set (ival lhs) (BoolI (bool-< ha lb) (bool-< la hb))))) - -; Rule that unions intervals for a gamma -(rule ( - (= lhs (Project i (Gamma pred ins (VVO outs)))) - (= (VO thens) (vec-get outs 1)) - (= (VO elses) (vec-get outs 0)) - (= thenival (ival (vec-get thens i))) - (= elseival (ival (vec-get elses i))) - ) - ( - (set (ival lhs) (interval-union thenival elseival)) - ) -) - -; Eliminate gamma with interval analysis -(rule ( - (= gamma (Gamma pred inputs (VVO outputs))) - (= (BoolI true true) (ival pred)) - ) - ( - (union gamma (OperandGroup (SubstVecOperandAll (vec-get outputs 1) inputs))) - ) -) -(rule ( - (= gamma (Gamma pred inputs (VVO outputs))) - (= (BoolI false false) (ival pred)) - ) - ( - (union gamma (OperandGroup (SubstVecOperandAll (vec-get outputs 0) inputs))) - ) -) - -(rule - ( - ; Match on PureOp because all exprs are converted to bodies - ; Will refactor Call in the future - (= return (PureOp (Call ty name args num)) ) - (Func name input-types output-types body) - ) - (( - union - return - (OperandGroup (SubstVecOperandAll body args)) - )) -) - - (rule - ((= num (Node (PureOp (Const (IntT) (const) (Num n1))))) - (= lhs (badd (IntT) other num))) - ((union lhs (badd (IntT) num other)))) - - (rule - ((= num (Node (PureOp (Const (IntT) (const) (Num n1))))) - (= lhs (bmul (IntT) other num))) - ((union lhs (bmul (IntT) num other)))) - - (rule - ((= lhs (badd (IntT) - (Node (PureOp (badd (IntT) a b))) - c))) - ((union lhs - (badd (IntT) - a - (Node (PureOp (badd (IntT) b c))))))) - - - (rule - ((= lhs (badd (IntT) - a - (Node (PureOp (badd (IntT) b c))))) - (= b (Node (PureOp (Const (IntT) (const) (Num n1))))) - ) - ((union lhs - (badd (IntT) - b - (Node (PureOp (badd (IntT) a c)))))) - ) - - - (rule - ((= lhs (badd (IntT) - a - (Node (PureOp (badd (IntT) b c))))) - (= a (Node (PureOp (Const (IntT) (const) (Num n1))))) - (= b (Node (PureOp (Const (IntT) (const) (Num n2)))))) - - ((union lhs - (badd (IntT) - (Node (PureOp (Const (IntT) (const) (Num (+ n1 n2))))) - c)))) - - -(let v0 "main") -(let v1 (IntT)) -(let v2 (Bril v1)) -(let v3 (PrintState)) -(let v4 (vec-of v2 v2 v3)) -(let v5 (vec-of v3)) -(let v6 1) -(let v7 2) -(let v8 (BoolT)) -(let v9 (Arg v6)) -(let v10 4) -(let v11 (Arg v10)) -(let v12 (blt v8 v9 v11)) -(let v13 (PureOp v12)) -(let v14 (Node v13)) -(let v15 0) -(let v16 (Arg v15)) -(let v17 (Arg v7)) -(let v18 3) -(let v19 (Arg v18)) -(let v20 (vec-of v16 v9 v17 v19 v11)) -(let v21 (VO v20)) -(let v22 (const)) -(let v23 (Num v15)) -(let v24 (Const v1 v22 v23)) -(let v25 (PureOp v24)) -(let v26 (Node v25)) -(let v27 (vec-of v16 v9 v26 v17 v19 v11)) -(let v28 (VO v27)) -(let v29 (blt v8 v19 v11)) -(let v30 (PureOp v29)) -(let v31 (Node v30)) -(let v32 5) -(let v33 (Arg v32)) -(let v34 (vec-of v16 v9 v17 v19 v11 v33)) -(let v35 (VO v34)) -(let v36 (vec-of v16 v9 v17 v26 v19 v11 v33)) -(let v37 (VO v36)) -(let v38 (bmul v1 v9 v11)) -(let v39 (PureOp v38)) -(let v40 (Node v39)) -(let v41 (badd v1 v40 v19)) -(let v42 (PureOp v41)) -(let v43 (Node v42)) -(let v44 (PRINT v43 v16)) -(let v45 (PureOp v44)) -(let v46 (Node v45)) -(let v47 (Num v6)) -(let v48 (Const v1 v22 v47)) -(let v49 (PureOp v48)) -(let v50 (Node v49)) -(let v51 (badd v1 v19 v17)) -(let v52 (PureOp v51)) -(let v53 (Node v52)) -(let v54 (vec-of v46 v9 v17 v50 v53 v11 v33)) -(let v55 (VO v54)) -(let v56 (vec-of v37 v55)) -(let v57 (VVO v56)) -(let v58 (Gamma v31 v35 v57)) -(let v59 (Project v18 v58)) -(let v60 (vec-of v16 v9 v17 v26 v19 v11)) -(let v61 (VO v60)) -(let v62 (Project v15 v58)) -(let v63 (Project v6 v58)) -(let v64 (Project v7 v58)) -(let v65 (Project v10 v58)) -(let v66 (Project v32 v58)) -(let v67 6) -(let v68 (Project v67 v58)) -(let v69 (vec-of v62 v63 v64 v65 v66 v68)) -(let v70 (VO v69)) -(let v71 (Theta v59 v61 v70)) -(let v72 (Project v15 v71)) -(let v73 (Project v6 v71)) -(let v74 (Project v7 v71)) -(let v75 (badd v1 v73 v74)) -(let v76 (PureOp v75)) -(let v77 (Node v76)) -(let v78 (Project v10 v71)) -(let v79 (Project v32 v71)) -(let v80 (vec-of v72 v77 v50 v74 v78 v79)) -(let v81 (VO v80)) -(let v82 (vec-of v28 v81)) -(let v83 (VVO v82)) -(let v84 (Gamma v14 v21 v83)) -(let v85 (Project v7 v84)) -(let v86 (vec-of v17 v26 v50 v9 v16)) -(let v87 (VO v86)) -(let v88 (Project v15 v84)) -(let v89 (Project v6 v84)) -(let v90 (Project v18 v84)) -(let v91 (Project v10 v84)) -(let v92 (Project v32 v84)) -(let v93 (vec-of v88 v89 v90 v91 v92)) -(let v94 (VO v93)) -(let v95 (Theta v85 v87 v94)) -(let v96 (Project v6 v95)) -(let v97 (Project v15 v95)) -(let v98 (PRINT v96 v97)) -(let v99 (PureOp v98)) -(let v100 (Node v99)) -(let v101 (vec-of v100)) -(let v102 (VO v101)) -(let v103 (Func v0 v4 v5 v102)) - -(run-schedule - ; only repeating twice to reduce benchmark CI performance - ; increasing to 3 times will change benchmark time from 4 minutes to 40+ minutes - (repeat 2 (saturate fast-analyses) - (run) - (saturate subst))) diff --git a/tests/eqsat-basic-multiset.egg b/tests/eqsat-basic-multiset.egg deleted file mode 100644 index e4a9fa0..0000000 --- a/tests/eqsat-basic-multiset.egg +++ /dev/null @@ -1,124 +0,0 @@ -;; Example showing how to use multisets to hold associative & commutative operations - -(datatype* - (Math - (Num i64) - (Var String) - (Add Math Math) - (Mul Math Math) - (Product MathMultiSet) - (Sum MathMultiSet)) - (sort MathToMath (UnstableFn (Math) Math)) - (sort MathMultiSet (MultiSet Math))) - -;; expr1 = 2 * (x + 3) -(let expr1 (Mul (Num 2) (Add (Var "x") (Num 3)))) -;; expr2 = 6 + 2 * x -(let expr2 (Add (Num 6) (Mul (Num 2) (Var "x")))) - -(rewrite (Add a b) (Sum (multiset-of a b))) -(rewrite (Mul a b) (Product (multiset-of a b))) - -;; 0 or 1 elements sums/products also can be extracted back to numbers -(rule - ( - (= sum (Sum sum-inner)) - (= 0 (multiset-length sum-inner)) - ) - ((union sum (Num 0))) -) -(rule - ( - (= sum (Sum sum-inner)) - (= 1 (multiset-length sum-inner)) - ) - ((union sum (multiset-pick sum-inner))) -) - -(rule - ( - (= product (Product product-inner)) - (= 0 (multiset-length product-inner)) - ) - ((union product (Num 1))) -) -(rule - ( - (= product (Product product-inner)) - (= 1 (multiset-length product-inner)) - ) - ((union product (multiset-pick product-inner))) -) - -; (rewrite (Mul a (Add b c)) -; (Add (Mul a b) (Mul a c))) - -; -> we would like to write it like this, but cannot (yet) bc we can't match on the inner structure of the multisets -; and we don't support anonymous functions - -; (rewrite (Product (multiset-insert a (Sum bc))) -; (Sum (multiset-map (lambda (x) (Product (multiset-insert a x))) bc))) - - -;; so instead we can define a function and partially apply it to get the same function as the lambda -(function tmp-fn (MathMultiSet Math) Math) -(rewrite (tmp-fn xs x) (Product (multiset-insert xs x))) - -(rule - ( - ;; and we can do a cross product search of all possible pairs of products/sums to find one we want - (= sum (Sum bc)) - (= product (Product product-inner)) - (multiset-contains product-inner sum) - (> (multiset-length product-inner) 1) - (= a (multiset-remove product-inner sum)) - ) - ( - (union product (Sum - (unstable-multiset-map - (unstable-fn "tmp-fn" a) - bc) - )) - ) -) - -; (rewrite (Add (Num a) (Num b)) -; (Num (+ a b))) - -(rule - ( - (= sum (Sum sum-inner)) - (= num-a (Num a)) - (multiset-contains sum-inner num-a) - (= without-a (multiset-remove sum-inner num-a)) - (= num-b (Num b)) - (multiset-contains without-a num-b) - ) - ( - (union sum - (Sum (multiset-insert (multiset-remove without-a num-b) (Num (+ a b)))) - ) - ) -) - -; (rewrite (Mul (Num a) (Num b)) -; (Num (* a b))) - -(rule - ( - (= product (Product product-inner)) - (= num-a (Num a)) - (multiset-contains product-inner num-a) - (= without-a (multiset-remove product-inner num-a)) - (= num-b (Num b)) - (multiset-contains without-a num-b) - ) - ( - (union product - (Product (multiset-insert (multiset-remove without-a num-b) (Num (* a b)))) - ) - ) -) - -(run 100) -(check (= expr1 expr2)) diff --git a/tests/eqsat-basic.egg b/tests/eqsat-basic.egg deleted file mode 100644 index 4831dbf..0000000 --- a/tests/eqsat-basic.egg +++ /dev/null @@ -1,25 +0,0 @@ -(datatype Math - (Num i64) - (Var String) - (Add Math Math) - (Mul Math Math)) - -;; expr1 = 2 * (x + 3) -(let expr1 (Mul (Num 2) (Add (Var "x") (Num 3)))) -;; expr2 = 6 + 2 * x -(let expr2 (Add (Num 6) (Mul (Num 2) (Var "x")))) - - -;; (rule ((= __root (Add a b))) -;; ((union __root (Add b a))) -(rewrite (Add a b) - (Add b a)) -(rewrite (Mul a (Add b c)) - (Add (Mul a b) (Mul a c))) -(rewrite (Add (Num a) (Num b)) - (Num (+ a b))) -(rewrite (Mul (Num a) (Num b)) - (Num (* a b))) - -(run 10) -(check (= expr1 expr2)) diff --git a/tests/eqsolve.egg b/tests/eqsolve.egg deleted file mode 100644 index 065528f..0000000 --- a/tests/eqsolve.egg +++ /dev/null @@ -1,45 +0,0 @@ -(datatype Expr - (Add Expr Expr) - (Neg Expr) - (Num i64) - (Mul Expr Expr) - (Var String) -) - -(rewrite (Add x y) (Add y x)) -(rewrite (Add (Add x y) z) (Add x (Add y z))) -(rewrite (Add (Num x) (Num y)) (Num (+ x y))) -(rule ((= (Add x y) z)) - ((union (Add z (Neg y)) x))) -(rewrite (Neg (Neg x)) x) -(rewrite (Neg (Num n)) (Num (- 0 n))) - -(rule ((= x (Var v))) ((union (Mul (Num 1) x) x))) -(rule ((= x (Add x1 x2))) ((union (Mul (Num 1) x) x))) -(rewrite (Add (Mul y x) (Mul z x)) (Mul (Add y z) x)) -(rewrite (Mul x y) (Mul y x)) -(rule ((= (Mul (Num x) y) (Num z)) - (= (% z x) 0)) - ((union y (Num (/ z x))))) - -; system 1: x + 2 = 7 -(union (Add (Var "x") (Num 2)) (Num 7)) -; system 2: z + y = 6, 2z = y -(union (Add (Var "z") (Var "y")) (Num 6)) -(union (Add (Var "z") (Var "z")) (Var "y")) - -(run 5) -(query-extract (Var "x")) -(query-extract (Var "y")) -(query-extract (Var "z")) -(check (= (Var "z") (Add (Num 6) (Neg (Var "y"))))) -(check (= (Var "y") (Add (Add (Num 6) (Neg (Var "y"))) (Add (Num 6) (Neg (Var "y")))))) -(check (= (Var "y") (Add (Add (Num 12) (Neg (Var "y"))) (Neg (Var "y"))))) -(check (= (Add (Var "y") (Var "y")) - (Add (Num 12) (Neg (Var "y"))))) -(check (= (Add (Add (Var "y") (Var "y")) (Var "y")) - (Num 12))) -(check (= (Add (Mul (Num 2) (Var "y")) (Var "y")) - (Num 12))) -(check (= (Mul (Num 3) (Var "y")) - (Num 12))) diff --git a/tests/f64.egg b/tests/f64.egg deleted file mode 100644 index 23301bf..0000000 --- a/tests/f64.egg +++ /dev/null @@ -1,13 +0,0 @@ -(check (= (neg 1.5) -1.5)) -(check (= (+ 1.5 9.2) 10.7)) -(check (= (/ 12.5 2.0) 6.25)) -(check (< 1.5 9.2)) -(check (>= 9.2 1.5)) -(check (= (^ 9.0 2.5) 243.0)) -(fail (check (= (^ 4.0 2.5) 31.99))) -(fail (check (< 9.2 1.5))) -(fail (check (= (+ 1.5 9.2) 10.6))) -(check (= (to-f64 1) 1.0)) -(check (= (to-i64 1.0) 1)) -(check (= (to-string 1.2) "1.2")) -(check (= (to-string 1.0) "1.0")) diff --git a/tests/fail-typecheck/repro-containers-disallowed.egg b/tests/fail-typecheck/repro-containers-disallowed.egg deleted file mode 100644 index ed76d3a..0000000 --- a/tests/fail-typecheck/repro-containers-disallowed.egg +++ /dev/null @@ -1,4 +0,0 @@ -(sort IVec (Vec i64)) - -; Test vec-of -(fail (check (= (vec-of 1 2) (vec-push (vec-push (vec-empty) 1) 2)))) diff --git a/tests/fail-typecheck/repro-duplicated-var.egg b/tests/fail-typecheck/repro-duplicated-var.egg deleted file mode 100644 index 2340aa7..0000000 --- a/tests/fail-typecheck/repro-duplicated-var.egg +++ /dev/null @@ -1,3 +0,0 @@ -(function f (i64) i64) -;; the let's y should fail checking -(rule ((= x 1) (= y x)) ((let y (f 1)) (set (f 0) 0))) \ No newline at end of file diff --git a/tests/fail-typecheck/unbound.egg b/tests/fail-typecheck/unbound.egg deleted file mode 100644 index d537a32..0000000 --- a/tests/fail-typecheck/unbound.egg +++ /dev/null @@ -1,6 +0,0 @@ -(datatype Math - (Add Math Math) - (Sub Math Math) -) - -(rule ((= e (Add x y))) ((Add x i))) diff --git a/tests/fail-typecheck/unstable-fn-wrong-args-type.egg b/tests/fail-typecheck/unstable-fn-wrong-args-type.egg deleted file mode 100644 index ab109e4..0000000 --- a/tests/fail-typecheck/unstable-fn-wrong-args-type.egg +++ /dev/null @@ -1,8 +0,0 @@ -;; test that you can't resolve a function with the wrong type of args - -(datatype Math - (Zero) - (Inc Math)) - -(sort Fn (UnstableFn (i64) Math)) -(unstable-fn "Inc") diff --git a/tests/fail-typecheck/unstable-fn-wrong-args.egg b/tests/fail-typecheck/unstable-fn-wrong-args.egg deleted file mode 100644 index 52ec6c3..0000000 --- a/tests/fail-typecheck/unstable-fn-wrong-args.egg +++ /dev/null @@ -1,8 +0,0 @@ -;; test that applying a function with the wrong number of args will violate the type checker - - -(datatype Math - (Inc Math)) - -(sort Fn (UnstableFn (Math) Math)) -(unstable-app (unstable-fn "Inc") 10) diff --git a/tests/fail-typecheck/unstable-fn-wrong-return-type.egg b/tests/fail-typecheck/unstable-fn-wrong-return-type.egg deleted file mode 100644 index be7e242..0000000 --- a/tests/fail-typecheck/unstable-fn-wrong-return-type.egg +++ /dev/null @@ -1,8 +0,0 @@ -;; test that you can't resolve a function with the wrong return type - -(datatype Math - (Zero) - (Inc Math)) - -(sort Fn (UnstableFn (Math) i64)) -(unstable-fn "Inc") diff --git a/tests/fail-typecheck/unstable-fn-wrong-return.egg b/tests/fail-typecheck/unstable-fn-wrong-return.egg deleted file mode 100644 index 9abe516..0000000 --- a/tests/fail-typecheck/unstable-fn-wrong-return.egg +++ /dev/null @@ -1,11 +0,0 @@ -;; test that the value of a applied function is well typed - - -(datatype Math - (Zero) - (Inc Math)) - -(sort Fn (UnstableFn (Math) Math)) -(let x (unstable-app (unstable-fn "Inc") (Zero))) - -(+ x 10) diff --git a/tests/fail_wrong_assertion.egg b/tests/fail_wrong_assertion.egg deleted file mode 100644 index ccabd0f..0000000 --- a/tests/fail_wrong_assertion.egg +++ /dev/null @@ -1,24 +0,0 @@ -;; This test ensure check test fails for wrong assertion -(function f (i64) i64 :merge (min old new)) - -(set (f 1) 4) -(set (f 1) 5) - -(check (= (f 1) 4)) -(fail (check (= (f 1) 2))) - -(delete (f 1)) -(fail (check (= (f 1) 4))) - -(function g (i64 i64) i64 :merge (min old new)) - -(set (g 1 2) 3) -(set (g 2 3) 3) - -(check (= (g 1 2) (g 2 3))) -(fail (check (!= (g 1 2) (g 2 3)))) -(fail (check (= (g 0 2) (g 2 3)))) -(check (= x (g 1 2))) -(fail (check (= x (g 1 3)))) -(check (= x (g 1 2)) (= y (g 2 3)) (= x y)) -(fail (check (= x (g 0 0)) (= y (g 1 1)) (= x y))) \ No newline at end of file diff --git a/tests/fibonacci-demand.egg b/tests/fibonacci-demand.egg deleted file mode 100644 index 22d13f0..0000000 --- a/tests/fibonacci-demand.egg +++ /dev/null @@ -1,19 +0,0 @@ -(datatype Expr - (Num i64 :cost 1) - (Add Expr Expr :cost 5)) - -(function Fib (i64) Expr :cost 10) - -(rewrite (Add (Num a) (Num b)) (Num (+ a b))) -(rewrite (Fib x) (Add (Fib (- x 1)) (Fib (- x 2))) - :when ((> x 1))) -(rewrite (Fib x) (Num x) - :when ((<= x 1))) - -(let f7 (Fib 7)) -(run 1000) -(print-function Fib 10) -(extract f7) -(check (= f7 (Num 13))) - - \ No newline at end of file diff --git a/tests/fibonacci.egg b/tests/fibonacci.egg deleted file mode 100644 index 89733f8..0000000 --- a/tests/fibonacci.egg +++ /dev/null @@ -1,11 +0,0 @@ -(function fib (i64) i64) -(set (fib 0) 0) -(set (fib 1) 1) - -(rule ((= f0 (fib x)) - (= f1 (fib (+ x 1)))) - ((set (fib (+ x 2)) (+ f0 f1)))) - -(run 7) - -(check (= (fib 7) 13)) \ No newline at end of file diff --git a/tests/fusion.egg b/tests/fusion.egg deleted file mode 100644 index 4aa853a..0000000 --- a/tests/fusion.egg +++ /dev/null @@ -1,152 +0,0 @@ -(datatype Var) -(datatype Term - (App Term Term) - (Lam Var Term) - (TVar Var) - (Let Var Term Term) - (Add Term Term) - (Num i64) - (CaseSplit Term Term Term) - (Cons Term Term)) -(function NilConst () Term) -(let Nil (NilConst)) - -(function V (String) Var) -(function From (Term) Var) - -;; ==== FV ==== -(sort StringSet (Set Var)) -(function freer (Term) StringSet :merge (set-intersect old new)) -(rule ((= e (App e1 e2)) - (= (freer e1) fv1) - (= (freer e2) fv2)) - ((set (freer e) (set-union fv1 fv2)))) -(rule ((= e (Lam var body)) - (= (freer body) fv)) - ((set (freer e) (set-remove fv var)))) -(rule ((= e (TVar v))) - ((set (freer e) (set-insert (set-empty) v)))) -(rule ((= e (Let var e1 e2)) - (= (freer e1) fv1) - (= (freer e2) fv2)) - ((set (freer e) (set-union fv1 (set-remove fv2 var))))) -(rule ((= e (Add e1 e2)) - (= (freer e1) fv1) - (= (freer e2) fv2)) - ((set (freer e) (set-union fv1 fv2)))) -(rule ((= e (Num v))) - ((set (freer e) (set-empty)))) -(rule ((= e (CaseSplit e1 e2 e3)) - (= (freer e1) fv1) - (= (freer e2) fv2) - (= (freer e3) fv3)) - ((set (freer e) (set-union (set-union fv1 fv2) fv3)))) -(rule ((= e (Cons e1 e2)) - (= (freer e1) fv1) - (= (freer e2) fv2)) - ((set (freer e) (set-union fv1 fv2)))) -(rule ((= e Nil)) - ((set (freer e) (set-empty)))) - -;; ==== eval ==== -; beta -(rewrite (App (Lam v body) e) (Let v e body)) -; case-split-nil -(rewrite (CaseSplit Nil e1 e2) e1) -; case-split-cons -(rewrite (CaseSplit (Cons x xs) e1 e2) (App (App e2 x) xs)) - -; let-num -(rewrite (Let v e (Num n)) (Num n)) -; let-nil -(rewrite (Let v e Nil) Nil) -; let-var-same -(rewrite (Let v1 e (TVar v1)) e) -; let-var-diff -(rewrite (Let v1 e (TVar v2)) (TVar v2) :when ((!= v1 v2))) - -; let-lam-close -(rewrite (Let v1 e expr) expr :when ((set-not-contains (freer expr) v1))) -; let-app -(rewrite (Let v e expr) (App (Let v e a) (Let v e b)) :when ((= expr (App a b)) (set-contains (freer expr) v))) -; let-add -(rewrite (Let v e expr) (Add (Let v e a) (Let v e b)) :when ((= expr (Add a b)) (set-contains (freer expr) v))) -; let-cons -(rewrite (Let v e expr) (Cons (Let v e x) (Let v e xs)) :when ((= expr (Cons x xs)) (set-contains (freer expr) v))) -; let-case-split -(rewrite (Let v e expr) - (CaseSplit (Let v e e1) (Let v e e2) (Let v e e3)) - :when ((= expr (CaseSplit e1 e2 e3)) - (set-contains (freer expr) v))) -; let-lam-same -(rewrite (Let v1 e (Lam v1 body)) (Lam v1 body)) -; let-lam-diff -(rewrite (Let v1 e (Lam v2 body)) (Lam v2 (Let v1 e body)) - :when ((set-contains (freer body) v1) - (!= v1 v2) - (= fvs (freer e)) - (set-not-contains fvs v2))) -(rule ((= expr (Let v1 e (Lam v2 body))) - (set-contains (freer body) v1) - (!= v1 v2) - (= fvs (freer e)) - (set-contains fvs v2)) - ((union expr (Lam (From expr) (Let v1 e (Let v2 (TVar (From expr)) body)))))) - -(function pushdown (Term Term) Term :cost 10000) -(rewrite (App f (App (Lam x e) e2)) - (App (Lam x (pushdown f e)) e2)) - -(rewrite (pushdown f (CaseSplit e e1 (Lam x (Lam xs e2)))) - (CaseSplit e (App f e1) (Lam x (Lam xs (App f e2))))) - -(relation is-tail (Term)) -(rule ((= demand (pushdown f e)) (= e (App e1 e2))) ((is-tail e))) -(rule ((= demand (pushdown f e)) (= e (Lam x e))) ((is-tail e))) -(rule ((= demand (pushdown f e)) (= e (TVar x))) ((is-tail e))) -(rule ((= demand (pushdown f e)) (= e (Cons e1 e2))) ((is-tail e))) -(rule ((= demand (pushdown f e)) (= e Nil)) ((is-tail e))) -(rule ((= demand (pushdown f e)) (= e (Add e1 e2))) ((is-tail e))) -(rule ((= demand (pushdown f e)) (= e (Num n1))) ((is-tail e))) -(rewrite (pushdown f e) (App f e) :when ((is-tail e))) - -;; ==== definition ==== - -(function sum () Term :cost 1000) -(function mapf () Term :cost 1000) -(function sum-o-mapf () Term) -(rewrite (App (sum) (App (mapf) x)) (App (sum-o-mapf) x)) -(union (sum) (Lam (V "xs") - (CaseSplit (TVar (V "xs")) - (Num 0) - (Lam (V "x") (Lam (V "xs'") - (Add (TVar (V "x")) (App (sum) (TVar (V "xs'"))))))))) - -(union (mapf) (Lam (V "xs") - (CaseSplit (TVar (V "xs")) - Nil - (Lam (V "x") (Lam (V "xs'") - (Cons (Add (TVar (V "x")) (Num 1)) - (App (mapf) (TVar (V "xs'"))))))))) - -(set (freer (sum)) (set-empty)) -(set (freer (mapf)) (set-empty)) - -(let expr (App (sum) (App (mapf) (TVar (V "expr"))))) - -(run 100) - -(query-extract (freer expr)) - - -(let my-output - (CaseSplit (TVar (V "expr")) (Num 0) - (Lam (V "x") (Lam (V "xs'") - (Add (Add (TVar (V "x")) (Num 1)) - (App (sum-o-mapf) (TVar (V "xs'")))))))) - -(check (= (App (sum-o-mapf) (TVar (V "expr"))) - (CaseSplit (TVar (V "expr")) (Num 0) - (Lam (V "x") (Lam (V "xs'") - (Add (Add (TVar (V "x")) (Num 1)) - (App (sum-o-mapf) (TVar (V "xs'"))))))))) diff --git a/tests/i64.egg b/tests/i64.egg deleted file mode 100644 index 00728eb..0000000 --- a/tests/i64.egg +++ /dev/null @@ -1 +0,0 @@ -(check (= (to-string 20) "20")) diff --git a/tests/include.egg b/tests/include.egg deleted file mode 100644 index 14a6040..0000000 --- a/tests/include.egg +++ /dev/null @@ -1,2 +0,0 @@ -(include "tests/path.egg") -(check (path 1 3)) diff --git a/tests/integer_math.egg b/tests/integer_math.egg deleted file mode 100644 index 747fc86..0000000 --- a/tests/integer_math.egg +++ /dev/null @@ -1,106 +0,0 @@ -(datatype Math - (Diff Math Math) - (Integral Math Math) - - (Add Math Math) - (Sub Math Math) - (Mul Math Math) - (Div Math Math) - (Pow Math Math) - (RShift Math Math) - (LShift Math Math) - (Mod Math Math) - (Not Math) - - (Const i64) - (Var String)) - -(relation MathU (Math)) -(rule ((= e (Diff x y))) ((MathU e))) -(rule ((= e (Integral x y))) ((MathU e))) -(rule ((= e (Add x y))) ((MathU e))) -(rule ((= e (Sub x y))) ((MathU e))) -(rule ((= e (Mul x y))) ((MathU e))) -(rule ((= e (Div x y))) ((MathU e))) -(rule ((= e (Pow x y))) ((MathU e))) -(rule ((= e (Const x))) ((MathU e))) -(rule ((= e (Var x))) ((MathU e))) -(rule ((= e (RShift x y))) ((MathU e))) -(rule ((= e (LShift x y))) ((MathU e))) -(rule ((= e (Mod x y))) ((MathU e))) -(rule ((= e (Not x))) ((MathU e))) - -(relation evals-to (Math i64)) -(rule ((evals-to x vx)) ((union x (Const vx)))) -(rule ((= e (Const c))) ((evals-to e c))) - -(relation is-not-zero (Math)) -(rule ((MathU a) (!= a (Const 0))) ((is-not-zero a))) - -;; Evaluation -(rewrite (Add (Const a) (Const b)) - (Const (+ a b))) -(rewrite (Sub (Const a) (Const b)) - (Const (- a b))) -(rewrite (Mul (Const a) (Const b)) (Const (* a b))) -(rewrite (Div (Const a) (Const b)) (Const (/ a b)) :when ((!= 0 b))) -(rewrite (RShift (Const a) (Const b)) (Const (>> a b))) -(rewrite (LShift (Const a) (Const b)) (Const (<< a b))) -(rewrite (Not (Const a)) (Const (not-i64 a))) - -;; Properties -(rewrite (Add a b) (Add b a)) -(rewrite (Mul a b) (Mul b a)) -(rewrite (Add a (Add b c)) (Add (Add a b) c)) -(rewrite (Mul a (Mul b c)) (Mul (Mul a b) c)) - -(rewrite (Sub a b) (Add a (Mul (Const -1) b))) - -(rewrite (Add a (Const 0)) a) -(rewrite (Mul a (Const 0)) (Const 0)) -(rewrite (Mul a (Const 1)) a) - -(rule ((MathU a) (!= a (Const 0))) ((union a (Add a (Const 0))))) -(rule ((MathU a) (!= a (Const 1))) ((union a (Mul a (Const 1))))) - -(rewrite (Sub a a) (Const 0)) -(rewrite (Div a a) (Const 1) :when ((is-not-zero a))) - -(rewrite (Mul a (Add b c)) (Add (Mul a b) (Mul a c))) -(rewrite (Add (Mul a b) (Mul a c)) (Mul a (Add b c))) - -; This rule doesn't work when pow is negative - consider 2^-1 * 2^1, which is 0, but 2^0 = 1 -(rewrite (Mul (Pow a b) (Pow a c)) (Pow a (Add b c)) :when ((is-not-zero b) (is-not-zero c))) - -(rewrite (Pow x (Const 0)) (Const 1) :when ((is-not-zero x))) -(rewrite (Pow x (Const 1 )) x) -(rewrite (Pow x (Const 2)) (Mul x x)) - -(rewrite (Pow x (Const -1)) (Div (Const 1) x) :when ((is-not-zero x))) - -(rewrite (Mul x (Pow (Const 2) y)) (LShift x y)) -(rewrite (Div x (Pow (Const 2) y)) (RShift x y)) - -(rewrite (Not (Not x)) x) - - -;; Tests -(let start-expr (Div ( - Mul (Var "a") (Pow (Const 2) (Const 3)) - ) ( - Add (Var "c") ( - Sub (Mul (Var "b") (Const 2)) (Mul (Var "b") (Const 2)) - ) - ))) - -(let equiv-expr (Div ( - LShift (Var "a") (Const 3) - ) ( - Mul (Var "c") (Not (Not (Const 1))) - ) - )) - -(run 4) - -(check (= start-expr equiv-expr)) - diff --git a/tests/integration_test.rs b/tests/integration_test.rs deleted file mode 100644 index 9418875..0000000 --- a/tests/integration_test.rs +++ /dev/null @@ -1,441 +0,0 @@ -use egglog::ast::Symbol; -use egglog::{ast::Expr, EGraph, ExtractReport, Function, SerializeConfig, Term, Value}; - -#[test] -fn test_subsumed_unextractable_action_extract() { - // Test when an expression is subsumed, it isn't extracted, even if its the cheapest - let mut egraph = EGraph::default(); - - egraph - .parse_and_run_program( - None, - r#" - (datatype Math) - (function exp () Math :cost 100) - (function cheap () Math :cost 1) - (union (exp) (cheap)) - (query-extract (exp)) - "#, - ) - .unwrap(); - // Originally should give back numeric term - assert!(matches!( - egraph.get_extract_report(), - Some(ExtractReport::Best { - term: Term::App(s, ..), - .. - }) if s == &Symbol::from("cheap") - )); - // Then if we make one as subsumed, it should give back the variable term - egraph - .parse_and_run_program( - None, - r#" - (subsume (cheap)) - (query-extract (exp)) - "#, - ) - .unwrap(); - assert!(matches!( - egraph.get_extract_report(), - Some(ExtractReport::Best { - term: Term::App(s, ..), - .. - }) if s == &Symbol::from("exp") - )); -} - -fn get_function(egraph: &EGraph, name: &str) -> Function { - egraph.functions.get(&Symbol::from(name)).unwrap().clone() -} -fn get_value(egraph: &EGraph, name: &str) -> Value { - get_function(egraph, name).get(&[]).unwrap() -} - -#[test] -fn test_subsumed_unextractable_rebuild_arg() { - // Tests that a term stays unextractable even after a rebuild after a union would change the value of one of its args - let mut egraph = EGraph::default(); - - egraph - .parse_and_run_program( - None, - r#" - (datatype Math) - (function container (Math) Math) - (function exp () Math :cost 100) - (function cheap () Math) - (function cheap-1 () Math) - ; we make the container cheap so that it will be extracted if possible, but then we mark it as subsumed - ; so the (exp) expr should be extracted instead - (let res (container (cheap))) - (union res (exp)) - (cheap) - (cheap-1) - (subsume (container (cheap))) - "#, - ).unwrap(); - // At this point (cheap) and (cheap-1) should have different values, because they aren't unioned - let orig_cheap_value = get_value(&egraph, "cheap"); - let orig_cheap_1_value = get_value(&egraph, "cheap-1"); - assert_ne!(orig_cheap_value, orig_cheap_1_value); - // Then we can union them - egraph - .parse_and_run_program( - None, - r#" - (union (cheap-1) (cheap)) - "#, - ) - .unwrap(); - egraph.rebuild_nofail(); - // And verify that their values are now the same and different from the original (cheap) value. - let new_cheap_value = get_value(&egraph, "cheap"); - let new_cheap_1_value = get_value(&egraph, "cheap-1"); - assert_eq!(new_cheap_value, new_cheap_1_value); - assert_ne!(new_cheap_value, orig_cheap_value); - // Now verify that if we extract, it still respects the unextractable, even though it's a different values now - egraph - .parse_and_run_program( - None, - r#" - (query-extract res) - "#, - ) - .unwrap(); - let report = egraph.get_extract_report().clone().unwrap(); - let ExtractReport::Best { term, termdag, .. } = report else { - panic!(); - }; - let expr = termdag.term_to_expr(&term); - assert_eq!(expr, Expr::call_no_span(Symbol::from("exp"), vec![])); -} - -#[test] -fn test_subsumed_unextractable_rebuild_self() { - // Tests that a term stays unextractable even after a rebuild after a union change its output value. - let mut egraph = EGraph::default(); - - egraph - .parse_and_run_program( - None, - r#" - (datatype Math) - (function container (Math) Math) - (function exp () Math :cost 100) - (function cheap () Math) - (let x (cheap)) - (subsume (cheap)) - "#, - ) - .unwrap(); - - let orig_cheap_value = get_value(&egraph, "cheap"); - // Then we can union them - egraph - .parse_and_run_program( - None, - r#" - (union (exp) x) - "#, - ) - .unwrap(); - egraph.rebuild_nofail(); - // And verify that the cheap value is now different - let new_cheap_value = get_value(&egraph, "cheap"); - assert_ne!(new_cheap_value, orig_cheap_value); - - // Now verify that if we extract, it still respects the subsumption, even though it's a different values now - egraph - .parse_and_run_program( - None, - r#" - (query-extract x) - "#, - ) - .unwrap(); - let report = egraph.get_extract_report().clone().unwrap(); - let ExtractReport::Best { term, termdag, .. } = report else { - panic!(); - }; - let expr = termdag.term_to_expr(&term); - assert_eq!(expr, Expr::call_no_span(Symbol::from("exp"), vec![])); -} - -#[test] -fn test_subsume_unextractable_insert_and_merge() { - // Example adapted from https://github.com/egraphs-good/egglog/pull/301#pullrequestreview-1756826062 - let mut egraph = EGraph::default(); - - egraph - .parse_and_run_program( - None, - r#" - (datatype Expr - (f Expr) - (Num i64)) - (function exp () Expr :cost 100) - - (f (Num 1)) - (subsume (f (Num 1))) - (f (Num 2)) - - (union (Num 2) (Num 1)) - (union (f (Num 2)) (exp)) - (extract (f (Num 2))) - "#, - ) - .unwrap(); - assert!(matches!( - egraph.get_extract_report(), - Some(ExtractReport::Best { - term: Term::App(s, ..), - .. - }) if s == &Symbol::from("exp") - )); -} - -#[test] -fn test_subsume_unextractable_action_extract_multiple() { - // Test when an expression is set as subsumed, it isn't extracted, like with - // extract multiple - let mut egraph = EGraph::default(); - - egraph - .parse_and_run_program( - None, - " - (datatype Math (Num i64)) - (Num 1) - (union (Num 1) (Num 2)) - (query-extract :variants 2 (Num 1)) - ", - ) - .unwrap(); - // Originally should give back two terms when extracted - let report = egraph.get_extract_report(); - assert!(matches!( - report, - Some(ExtractReport::Variants { terms, .. }) if terms.len() == 2 - )); - // Then if we make one unextractable, it should only give back one term - egraph - .parse_and_run_program( - None, - " - (subsume (Num 2)) - (query-extract :variants 2 (Num 1)) - ", - ) - .unwrap(); - let report = egraph.get_extract_report(); - assert!(matches!( - report, - Some(ExtractReport::Variants { terms, .. }) if terms.len() == 1 - )); -} - -#[test] -fn test_rewrite_subsumed_unextractable() { - // When a rewrite is marked as a subsumed, the lhs should not be extracted - - let mut egraph = EGraph::default(); - - egraph - .parse_and_run_program( - None, - r#" - (datatype Math) - (function exp () Math :cost 100) - (function cheap () Math :cost 1) - (rewrite (cheap) (exp) :subsume) - (cheap) - (run 1) - (extract (cheap)) - "#, - ) - .unwrap(); - // Should give back expenive term, because cheap is unextractable - assert!(matches!( - egraph.get_extract_report(), - Some(ExtractReport::Best { - term: Term::App(s, ..), - .. - }) if s == &Symbol::from("exp") - )); -} -#[test] -fn test_rewrite_subsumed() { - // When a rewrite is marked as a subsumed, the lhs should not be extracted - - let mut egraph = EGraph::default(); - - // If we rerite most-exp to another term, that rewrite shouldnt trigger since its been subsumed. - egraph - .parse_and_run_program( - None, - r#" - (datatype Math) - (function exp () Math :cost 100) - (function most-exp () Math :cost 1000) - (rewrite (most-exp) (exp) :subsume) - (most-exp) - (run 1) - (function cheap () Math :cost 1) - (rewrite (most-exp) (cheap)) - (run 1) - (extract (most-exp)) - "#, - ) - .unwrap(); - assert!(matches!( - egraph.get_extract_report(), - Some(ExtractReport::Best { - term: Term::App(s, ..), - .. - }) if s == &Symbol::from("exp") - )); -} - -#[test] -fn test_subsume() { - // Test that if we mark a term as subsumed than no rewrites will be applied to it. - // We can test this by adding a commutative additon property, and verifying it isn't applied on one of the terms - // but is on the other - let mut egraph = EGraph::default(); - egraph - .parse_and_run_program( - None, - r#" - (datatype Math - (Add Math Math) - (Num i64)) - - (rewrite (Add a b) (Add b a)) - (let x (Add (Num 1) (Num 2))) - (let y (Add (Num 3) (Num 4))) - (subsume (Add (Num 1) (Num 2))) - (run 1) - (extract y 10) - "#, - ) - .unwrap(); - assert!(matches!( - egraph.get_extract_report(), - Some(ExtractReport::Variants { terms, .. }) if terms.len() == 2 - )); - - egraph - .parse_and_run_program( - None, - r#" - ;; add something equal to x that can be extracted: - (function otherConst () Math) - (let other (otherConst)) - (union x other) - (extract x 10) - "#, - ) - .unwrap(); - assert!(matches!( - egraph.get_extract_report(), - Some(ExtractReport::Variants { terms, .. }) if terms.len() == 1 - )); -} - -#[test] -fn test_subsume_primitive() { - // Test that we can subsume a primitive - - let mut egraph = EGraph::default(); - let res = egraph.parse_and_run_program( - None, - r#" - (function one () i64) - (set (one) 1) - (subsume (one)) - "#, - ); - assert!(res.is_ok()); -} - -#[test] -fn test_cant_subsume_merge() { - // Test that we can't subsume something with a merge function - - let mut egraph = EGraph::default(); - let res = egraph.parse_and_run_program( - None, - r#" - (function one () i64 :merge old) - (set (one) 1) - (subsume (one)) - "#, - ); - assert!(res.is_err()); -} - -#[test] -fn test_value_to_classid() { - let mut egraph = EGraph::default(); - - egraph - .parse_and_run_program( - None, - r#" - (datatype Math) - (function exp () Math ) - (exp) - (query-extract (exp)) - "#, - ) - .unwrap(); - let report = egraph.get_extract_report().clone().unwrap(); - let ExtractReport::Best { term, termdag, .. } = report else { - panic!(); - }; - let expr = termdag.term_to_expr(&term); - let (sort, value) = egraph.eval_expr(&expr).unwrap(); - - let serialized = egraph.serialize(SerializeConfig::default()); - let class_id = egraph.value_to_class_id(&sort, &value); - assert!(serialized.class_data.get(&class_id).is_some()); - assert_eq!(value, egraph.class_id_to_value(&class_id)); -} - -#[test] -fn test_serialize_subsume_status() { - let mut egraph = EGraph::default(); - - egraph - .parse_and_run_program( - None, - r#" - (datatype Math) - (function a () Math ) - (function b () Math ) - (a) - (b) - (subsume (a)) - "#, - ) - .unwrap(); - - let serialized = egraph.serialize(SerializeConfig::default()); - let a_id = egraph.to_node_id( - None, - egglog::SerializedNode::Function { - name: ("a").into(), - offset: 0, - }, - ); - let b_id = egraph.to_node_id( - None, - egglog::SerializedNode::Function { - name: "b".into(), - offset: 0, - }, - ); - assert!(serialized.nodes[&a_id].subsumed); - assert!(!serialized.nodes[&b_id].subsumed); -} diff --git a/tests/intersection.egg b/tests/intersection.egg deleted file mode 100644 index b29aed7..0000000 --- a/tests/intersection.egg +++ /dev/null @@ -1,41 +0,0 @@ -;; computes "e-graph intersection" - -(datatype Expr - (Var String) - (f Expr)) - -(function intersect (Expr Expr) Expr) - -(rule ( - (= x3 (intersect x1 x2)) - (= f1 (f x1)) - (= f2 (f x2)) -)( - (union (intersect f1 f2) (f x3)) -)) - -(let a1 (Var "a1")) (let a2 (Var "a2")) (let a3 (Var "a3")) -(let b1 (Var "b1")) (let b2 (Var "b2")) (let b3 (Var "b3")) - -;; e-graph 1: f(a) = f(b), f(f(a)) -(let t1 (f (f a1))) -(let fb1 (f b1)) -(union (f a1) fb1) - -;; e-graph 2: f(f(a)) = f(f(b)) -(let t2 (f (f a2))) -(let t2p (f (f b2))) -(union t2 t2p) - -(union (intersect a1 a2) a3) -(union (intersect b1 b2) b3) - -(run 100) - -(let t3 (f (f a3))) -(query-extract :variants 5 t3) - -;; f(f(a)) = f(f(b)) is preserved -(check (= (f (f a3)) (f (f b3)))) -;; but not f(a) = f(b), it was only in e-graph 1 -(check (!= (f a3) (f b3))) \ No newline at end of file diff --git a/tests/knapsack.egg b/tests/knapsack.egg deleted file mode 100644 index e9a918a..0000000 --- a/tests/knapsack.egg +++ /dev/null @@ -1,46 +0,0 @@ -(datatype expr - (Num i64) - (Add expr expr) - (Max expr expr)) -(rewrite (Add (Num a) (Num b)) (Num (+ a b))) -(rewrite (Max (Num a) (Num b)) (Num (max a b))) - -; List of (weight, value) pairs -(datatype objects - (Cons i64 i64 objects)) -(function NilConst () objects) -(let Nil (NilConst)) - -; Given a capacity and a list of objects, finds the maximum value of a -; collection of objects whose total weight does not exceed the capacity. -(function Knap (i64 objects) expr) - -(rule ((= f (Knap capacity (Cons weight val rest))) (<= weight capacity)) - ((union (Knap capacity (Cons weight val rest)) - (Max - (Add (Num val) (Knap (- capacity weight) rest)) - (Knap capacity rest))))) - -(rule ((= f (Knap capacity (Cons weight val rest))) (> weight capacity)) - ((union (Knap capacity (Cons weight val rest)) - (Knap capacity rest)))) - -(rule ((= f (Knap capacity Nil))) - ((union (Knap capacity Nil) (Num 0)))) - -(let test1 (Knap 13 (Cons 5 5 (Cons 3 3 (Cons 12 12 (Cons 5 5 Nil)))))) - -(let test2 (Knap 5 (Cons 6 6 Nil))) - -(let test3 (Knap 5 (Cons 1 1 (Cons 1 1 (Cons 1 1 Nil))))) - -(let test4 (Knap 15 (Cons 12 40 (Cons 2 20 (Cons 1 20 (Cons 1 10 (Cons 4 100 Nil))))))) - -; turn a (Num n) into n -(function Unwrap (expr) i64) -(rule ((= x (Num n))) ((set (Unwrap (Num n)) n))) - -(run 100) - -(check (= test1 (Num 13))) - diff --git a/tests/lambda.egg b/tests/lambda.egg deleted file mode 100644 index 392e64c..0000000 --- a/tests/lambda.egg +++ /dev/null @@ -1,242 +0,0 @@ -;; NOTE: This file contains several unsafe operations -(datatype Value (Num i64)) -(function TrueConst () Value) -(let True (TrueConst)) -(function FalseConst () Value) -(let False (FalseConst)) -(datatype VarType) -(datatype Term - (Val Value) - (Var VarType) - (Add Term Term) - (Eq Term Term) - (App Term Term) - (Lam VarType Term) - (Let VarType Term Term) - (Fix VarType Term) - (If Term Term Term)) -(function V (String) VarType) -(function From (Term) VarType) - -; All free variables are free, -; but some free variables are more free than others -; Freer variables will only contain variables -; that will affect the evaluation -; of the corresponding term -; e.g., x is free in x - x, but not freer in x - x -(sort StringSet (Set VarType)) -(function freer (Term) StringSet :merge (set-intersect old new)) -(rule ((= e (Val v))) - ((set (freer e) (set-empty)))) -(rule ((= e (Var v))) - ((set (freer e) (set-insert (set-empty) v)))) -(rule ((= e (Add e1 e2)) - (= (freer e1) fv1) - (= (freer e2) fv2)) - ((set (freer e) (set-union fv1 fv2)))) -(rule ((= e (Eq e1 e2)) - (= (freer e1) fv1) - (= (freer e2) fv2)) - ((set (freer e) (set-union fv1 fv2)))) -(rule ((= e (App e1 e2)) - (= (freer e1) fv1) - (= (freer e2) fv2)) - ((set (freer e) (set-union fv1 fv2)))) -(rule ((= e (Lam var body)) - (= (freer body) fv)) - ((set (freer e) (set-remove fv var)))) -(rule ((= e (Let var e1 e2)) - (= (freer e1) fv1) - (= (freer e2) fv2)) - ((set (freer e) (set-union fv1 (set-remove fv2 var))))) -(rule ((= e (Fix var body)) - (= (freer body) fv)) - ((set (freer e) (set-remove fv var)))) -(rule ((= e (If c e1 e2)) - (= (freer c) fv1) - (= (freer e1) fv2) - (= (freer e2) fv3)) - ((set (freer e) (set-union fv1 (set-union fv2 fv3))))) - -;; START evals-to -(function evals-to (Term) Value) - -(rule ((= e (Val val))) - ((union (evals-to e) val))) -(rule ((= e (Add a b)) - (= (Num va) (evals-to a)) - (= (Num vb) (evals-to b))) - ((union (evals-to e) (Num (+ va vb))))) -(rule ((= e (Eq a b)) - (= (evals-to b) (evals-to a))) - ((union (evals-to e) True))) -(rule ((= e (Eq a b)) - (= va (evals-to a)) - (= vb (evals-to b)) - (!= va vb)) ; TODO: if true and false are non-mergeable datatype, - ; we should be able to do != over it - ((union (evals-to e) False))) -(rule ((= v (evals-to e))) - ((union e (Val v)))) -;; END evals-to - -; if-true -(rewrite (If (Val True) then else) then) -; if-false -(rewrite (If (Val False) then else) else) -; if-elim -(rule ((= term (If (Eq (Var x) e) then else))) - ((Let x e then) - (Let x e else))) -(rewrite (If (Eq (Var x) e) then else) else - :when ((= (Let x e then) (Let x e else)))) - -; add-comm -(rewrite (Add a b) (Add b a)) -; add-assoc -(rewrite (Add (Add a b) c) (Add a (Add b c))) -; eq-comm -(rewrite (Eq a b) (Eq b a)) - -; fix -(rewrite (Fix v e) (Let v (Fix v e) e)) -; beta -(rewrite (App (Lam v body) e) (Let v e body)) -; let-app -(rewrite (Let v e (App a b)) (App (Let v e a) (Let v e b))) -; let-add -(rewrite (Let v e (Add a b)) (Add (Let v e a) (Let v e b))) -; let-eq -(rewrite (Let v e (Eq a b)) (Eq (Let v e a) (Let v e b))) -; let-const -(rewrite (Let v e c) c :when ((= const (evals-to c)))) -; let-if -(rewrite (Let v e (If cond then else)) - (If (Let v e cond) (Let v e then) (Let v e else))) -; let-var-same -(rewrite (Let v1 e (Var v1)) e) -; let-var-diff -(rewrite (Let v1 e (Var v2)) (Var v2) :when ((!= v1 v2))) -; let-lam-same -(rewrite (Let v1 e (Lam v1 body)) (Lam v1 body)) -; let-lam-diff -(rewrite (Let v1 e (Lam v2 body)) (Lam v2 (Let v1 e body)) - :when ((!= v1 v2) - (= fvs (freer e)) - (set-not-contains fvs v2))) -(rule ((= expr (Let v1 e (Lam v2 body))) - (!= v1 v2) - (= fvs (freer e)) - (set-contains fvs v2)) - ((union expr (Lam (From expr) (Let v1 e (Let v2 (Var (From expr)) body)))))) - -;; lambda_under -(push) -(let e - (Lam (V "x") - (Add (Val (Num 4)) - (App (Lam (V "y") (Var (V "y"))) (Val (Num 4)))))) -(run 10) -(check (= e (Lam (V "x") (Val (Num 8))))) -(pop) - -;; lambda_if_elim -(push) -(let e2 (If (Eq (Var (V "a")) (Var (V "b"))) - (Add (Var (V "a")) (Var (V "a"))) - (Add (Var (V "a")) (Var (V "b"))))) -(run 10) -(check (= e2 (Add (Var (V "a")) (Var (V "b"))))) -(pop) - -;; lambda_let_simple -(push) -(let e3 (Let (V "x") (Val (Num 0)) - (Let (V "y") (Val (Num 1)) - (Add (Var (V "x")) (Var (V "y")))))) -(run 10) -(check (= e3 (Val (Num 1)))) -(pop) - -;; lambda_capture -(push) -(let e4 (Let (V "x") (Val (Num 1)) - (Lam (V "x") (Var (V "x"))))) -(run 10) -(fail (check (= e4 (Lam (V "x") (Val (Num 1)))))) -(pop) - -;; lambda_capture_free -(push) -(let e5 (Let (V "y") (Add (Var (V "x")) (Var (V "x"))) - (Lam (V "x") (Var (V "y"))))) -(run 10) -(check (set-contains (freer (Lam (V "x") (Var (V "y")))) (V "y"))) -(fail (check (= e5 (Lam (V "x") (Add (Var (V "x")) (Var (V "x"))))))) -(pop) - -;; lambda_closure_not_seven -(push) -(let e6 - (Let (V "five") (Val (Num 5)) - (Let (V "add-five") (Lam (V "x") (Add (Var (V "x")) (Var (V "five")))) - (Let (V "five") (Val (Num 6)) - (App (Var (V "add-five")) (Val (Num 1))))))) -(run 10) -(fail (check (= e6 (Val (Num 7))))) -(check (= e6 (Val (Num 6)))) -(pop) - - -;; lambda_compose -(push) -(let e7 - (Let (V "compose") (Lam (V "f") - (Lam (V "g") - (Lam (V "x") (App (Var (V "f")) - (App (Var (V "g")) - (Var (V "x"))))))) - (Let (V "add1") (Lam (V "y") (Add (Var (V "y")) (Val (Num 1)))) - (App (App (Var (V "compose")) (Var (V "add1"))) (Var (V "add1")))))) -(run 20) -(check (= e7 (Lam x (Add (Var x) (Val (Num 2)))))) -(pop) - -;; lambda_if_simple -(push) -(let e10 (If (Eq (Val (Num 1)) (Val (Num 1))) (Val (Num 7)) (Val (Num 9)))) -(run 4) -(check (= e10 (Val (Num 7)))) -(pop) - -;; lambda_compose_many -(push) -(let e11 - (Let (V "compose") (Lam (V "f") (Lam (V "g") (Lam (V "x") (App (Var (V "f")) - (App (Var (V "g")) (Var (V "x"))))))) - (Let (V "add1") (Lam (V "y") (Add (Var (V "y")) (Val (Num 1)))) - (App (App (Var (V "compose")) (Var (V "add1"))) - (App (App (Var (V "compose")) (Var (V "add1"))) - (App (App (Var (V "compose")) (Var (V "add1"))) - (App (App (Var (V "compose")) (Var (V "add1"))) - (App (App (Var (V "compose")) (Var (V "add1"))) - (App (App (Var (V "compose")) (Var (V "add1"))) - (Var (V "add1"))))))))))) - -(run 30) -(check (= e11 (Lam x (Add (Var x) (Val (Num 7)))))) -(pop) - -;; lambda_if -(push) -(let e8 - (Let (V "zeroone") (Lam (V "x") - (If (Eq (Var (V "x")) (Val (Num 0))) - (Val (Num 0)) - (Val (Num 1)))) - (Add (App (Var (V "zeroone")) (Val (Num 0))) - (App (Var (V "zeroone")) (Val (Num 10))))) -) -(run 20) -(check (= e8 (Val (Num 1)))) -(pop) diff --git a/tests/levenshtein-distance.egg b/tests/levenshtein-distance.egg deleted file mode 100644 index f67e9fd..0000000 --- a/tests/levenshtein-distance.egg +++ /dev/null @@ -1,71 +0,0 @@ -; Datatypes - -(datatype expr - (Num i64) - (Add expr expr) - (Min expr expr expr)) -(rewrite (Add (Num a) (Num b)) (Num (+ a b))) -(rewrite (Min (Num a) (Num b) (Num c)) (Num (min (min a b) c))) - -; `String` supports limited operations, let's just use it as a char type -(datatype str - (Cons String str)) -(function EmptyConst () str) -(let Empty (EmptyConst)) - -; Length function - -(function Length (str) expr) - -(rule ((= f (Length Empty))) - ((union (Length Empty) (Num 0)))) - -(rule ((= f (Length (Cons c cs)))) - ((union (Length (Cons c cs)) (Add (Num 1) (Length cs))))) - -; EditDist function - -(function EditDist (str str) expr) - -(rule ((= f (EditDist Empty s))) - ((union (EditDist Empty s) (Length s)))) - -(rule ((= f (EditDist s Empty))) - ((union (EditDist s Empty) (Length s)))) - -(rule ((= f (EditDist (Cons head rest1) (Cons head rest2)))) - ((union (EditDist (Cons head rest1) (Cons head rest2)) - (EditDist rest1 rest2)))) - -(rule ((= f (EditDist (Cons head1 rest1) (Cons head2 rest2))) (!= head1 head2)) - ((union (EditDist (Cons head1 rest1) (Cons head2 rest2)) - (Add (Num 1) - (Min (EditDist rest1 rest2) - (EditDist (Cons head1 rest1) rest2) - (EditDist rest1 (Cons head2 rest2))))))) - -; Unwrap function - turn a (Num n) into n - -(function Unwrap (expr) i64) -(rule ((= x (Num n))) ((set (Unwrap (Num n)) n))) - -; Tests -(let HorseStr (Cons "h" (Cons "o" (Cons "r" (Cons "s" (Cons "e" Empty)))))) -(let RosStr (Cons "r" (Cons "o" (Cons "s" Empty)))) -(let IntentionStr (Cons "i" (Cons "n" (Cons "t" (Cons "e" (Cons "n" (Cons "t" (Cons "i" (Cons "o" (Cons "n" Empty)))))))))) -(let ExecutionStr (Cons "e" (Cons "x" (Cons "e" (Cons "c" (Cons "u" (Cons "t" (Cons "i" (Cons "o" (Cons "n" Empty)))))))))) - -(let Test1 (EditDist HorseStr RosStr)) -(let Test2 (EditDist IntentionStr ExecutionStr)) -(let Test3 (EditDist HorseStr Empty)) - -(run 100) - -(extract (Unwrap Test1)) -(check (= Test1 (Num 3))) - -(extract (Unwrap Test2)) -(check (= Test2 (Num 5))) - -(extract (Unwrap Test3)) -(check (= Test3 (Num 5))) \ No newline at end of file diff --git a/tests/list.egg b/tests/list.egg deleted file mode 100644 index 31ab5a8..0000000 --- a/tests/list.egg +++ /dev/null @@ -1,73 +0,0 @@ -(datatype List - (Nil) - (Cons i64 List)) - -(ruleset list) - -(function list-length (List) i64) -(relation list-length-demand (List)) -(rule - ((list-length-demand (Nil))) - ((set (list-length (Nil)) 0)) - :ruleset list) -(rule - ((list-length-demand (Cons head tail))) - ((list-length-demand tail)) - :ruleset list) -(rule - ( (list-length-demand (Cons head tail)) - (= (list-length tail) tail-length)) - ((set (list-length (Cons head tail)) (+ tail-length 1))) - :ruleset list) - -(function list-get (List i64) i64) -(relation list-get-demand (List i64)) -(rule - ( (list-get-demand list 0) - (= list (Cons head tail))) - ((set (list-get list 0) head)) - :ruleset list) -(rule - ( (list-get-demand list n) (> n 0) - (= list (Cons head tail))) - ((list-get-demand tail (- n 1))) - :ruleset list) -(rule - ( (list-get-demand list n) - (= list (Cons head tail)) - (= item (list-get tail (- n 1)))) - ((set (list-get list n) item)) - :ruleset list) - -(function list-append (List List) List) -(rewrite (list-append (Nil) list) list :ruleset list) -(rewrite (list-append (Cons head tail) list) (Cons head (list-append tail list)) :ruleset list) - -; list-contains Nil _ => false -; list-contains (Cons item tail) item => true -; list-contains (Cons head tail) item => assert(head != item); (list-contains tail item) -; list-contains needs inequality - -(function list-set (List i64 i64) List) -(rewrite (list-set (Cons head tail) 0 item) (Cons item tail) :ruleset list) -(rewrite (list-set (Cons head tail) i item) (Cons head (list-set tail (- i 1) item)) :when ((> i 0)) :ruleset list) - -; Tests -(let a (Cons 1 (Cons 2 (Nil)))) -(let b (Cons 3 (Nil))) -(let c (Cons 1 (Cons 2 (Cons 3 (Nil))))) -(let d (Cons 1 (Cons 4 (Nil)))) -(let e (list-append a b)) -(let f (list-set a 1 4)) - -(list-length-demand c) -(list-get-demand b 0) -(list-get-demand a 1) - -(run-schedule (saturate (run list))) - -(check (= e c)) -(check (= (list-length c) 3)) -(check (= (list-get b 0) 3)) -(check (= (list-get a 1) 2)) -(check (= f d)) diff --git a/tests/map.egg b/tests/map.egg deleted file mode 100644 index 51e9897..0000000 --- a/tests/map.egg +++ /dev/null @@ -1,7 +0,0 @@ -(sort MyMap (Map i64 String)) - -(let my_map1 (map-insert (map-empty) 1 "one")) -(let my_map2 (map-insert my_map1 2 "two")) - -(check (= "one" (map-get my_map1 1))) -(query-extract my_map2) \ No newline at end of file diff --git a/tests/matrix.egg b/tests/matrix.egg deleted file mode 100644 index 98c03b3..0000000 --- a/tests/matrix.egg +++ /dev/null @@ -1,98 +0,0 @@ - -(datatype Dim (Times Dim Dim) (NamedDim String) (Lit i64)) - -(rewrite (Times a (Times b c)) (Times (Times a b) c)) -(rewrite (Times (Times a b) c) (Times a (Times b c)) ) -(rewrite (Times (Lit i) (Lit j)) (Lit (* i j))) -(rewrite (Times a b) (Times b a)) - -(datatype MExpr - (MMul MExpr MExpr) - (Kron MExpr MExpr) - (NamedMat String) - (Id Dim) - ; DSum - ; HStack - ; VStack - ; Transpose - ; Inverse - ; Zero Math Math - ; ScalarMul -) - -; alternative encoding (type A) = (Matrix n m) may be more useful for "large story example" -(function nrows (MExpr) Dim) -(function ncols (MExpr) Dim) - -(rewrite (nrows (Kron A B)) (Times (nrows A) (nrows B))) -(rewrite (ncols (Kron A B)) (Times (ncols A) (ncols B))) - -(rewrite (nrows (MMul A B)) (nrows A)) -(rewrite (ncols (MMul A B)) (ncols B)) - -(rewrite (nrows (Id n)) n) -(rewrite (ncols (Id n)) n) - -(rewrite (MMul (Id n) A) A) -(rewrite (MMul A (Id n)) A) - -(rewrite (MMul A (MMul B C)) (MMul (MMul A B) C)) -(rewrite (MMul (MMul A B) C) (MMul A (MMul B C))) - -(rewrite (Kron A (Kron B C)) (Kron (Kron A B) C)) -(rewrite (Kron (Kron A B) C) (Kron A (Kron B C))) - -(rewrite (Kron (MMul A C) (MMul B D)) (MMul (Kron A B) (Kron C D))) - - -(rewrite (MMul (Kron A B) (Kron C D)) - (Kron (MMul A C) (MMul B D)) - :when - ((= (ncols A) (nrows C)) - (= (ncols B) (nrows D))) -) - -; demand -(rule ((= e (MMul A B))) -((ncols A) -(nrows A) -(ncols B) -(nrows B)) -) - -(rule ((= e (Kron A B))) -((ncols A) -(nrows A) -(ncols B) -(nrows B)) -) - - -(let n (NamedDim "n")) -(let m (NamedDim "m")) -(let p (NamedDim "p")) - -(let A (NamedMat "A")) -(let B (NamedMat "B")) -(let C (NamedMat "C")) - -(union (nrows A) n) -(union (ncols A) n) -(union (nrows B) m) -(union (ncols B) m) -(union (nrows C) p) -(union (ncols C) p) -(let ex1 (MMul (Kron (Id n) B) (Kron A (Id m)))) -(let rows1 (nrows ex1)) -(let cols1 (ncols ex1)) - -(run 20) - -(check (= (nrows B) m)) -(check (= (nrows (Kron (Id n) B)) (Times n m))) -(let simple_ex1 (Kron A B)) -(check (= ex1 simple_ex1)) - -(let ex2 (MMul (Kron (Id p) C) (Kron A (Id m)))) -(run 10) -(fail (check (= ex2 (Kron A C)))) diff --git a/tests/merge-during-rebuild.egg b/tests/merge-during-rebuild.egg deleted file mode 100644 index 326705b..0000000 --- a/tests/merge-during-rebuild.egg +++ /dev/null @@ -1,18 +0,0 @@ -; This file tests that non-union merges can be triggered during rebuilds as well -; as "inline" during a set action. See issue #42 - -(datatype N (Node i64)) -(function distance (N N) i64 :merge (min old new)) - -(let a (Node 0)) -(let b (Node 1)) -(let x (Node 2)) -(let y (Node 3)) -(set (distance x y) 1) -(set (distance a b) 2) - -(union a x) -(union b y) - -(run 1) -(check (= (distance x y) 1)) ; fails, the distance has gone up! diff --git a/tests/merge-saturates.egg b/tests/merge-saturates.egg deleted file mode 100644 index 46f0d10..0000000 --- a/tests/merge-saturates.egg +++ /dev/null @@ -1,24 +0,0 @@ -(function foo () i64 :merge (min old new)) - -(set (foo) 0) - -; This should break at iteration 0 because the merge doesn't cause any updates -(rule ((= f (foo))) ((set (foo) 1))) -(run 100) - - -; This should run for about 50 iterations, because even though the merge doesn't -; change the value of baz, it has a side effect of expanding the domain of bar. - -(function baz (i64) i64 :default 0) - -(function bar () i64 :merge (min (baz new) 0)) - -(set (bar) 1) -(set (bar) 2) - -(rule ((= f (baz x)) (< x 50)) - ((set (bar) (+ x 1)))) - -(run 100) -(check (= 0 (baz 50))) diff --git a/tests/multiset.egg b/tests/multiset.egg deleted file mode 100644 index 795281c..0000000 --- a/tests/multiset.egg +++ /dev/null @@ -1,58 +0,0 @@ -(datatype Math (Num i64)) -(sort MathToMath (UnstableFn (Math) Math)) -(sort Maths (MultiSet Math)) - -(let xs (multiset-of (Num 1) (Num 2) (Num 3))) - -;; verify equal to other ordering -(check (= - (multiset-of (Num 3) (Num 2) (Num 1)) - xs -)) - -;; verify not equal to different counts -(check (!= - (multiset-of (Num 3) (Num 2) (Num 1) (Num 1)) - xs -)) - -;; Unclear why check won't work if this is defined inline -(let inserted (multiset-insert xs (Num 4))) -;; insert -(check (= - (multiset-of (Num 1) (Num 2) (Num 3) (Num 4)) - inserted -)) - - -;; contains and not contains -(check (multiset-contains xs (Num 1))) -(check (multiset-not-contains xs (Num 4))) - -;; remove last -(check (= - (multiset-of (Num 1) (Num 3)) - (multiset-remove xs (Num 2)) -)) -;; remove one of -(check (= (multiset-of (Num 1)) (multiset-remove (multiset-of (Num 1) (Num 1)) (Num 1)))) - - -;; length -(check (= 3 (multiset-length xs))) -;; length repeated -(check (= 3 (multiset-length (multiset-of (Num 1) (Num 1) (Num 1))))) - -;; pick -(check (= (Num 1) (multiset-pick (multiset-of (Num 1))))) - -;; map -(function square (Math) Math) -(rewrite (square (Num x)) (Num (* x x))) - -(let squared-xs (unstable-multiset-map (unstable-fn "square") xs)) -(run 1) -(check (= - (multiset-of (Num 1) (Num 4) (Num 9)) - squared-xs -)) diff --git a/tests/name-resolution.egg b/tests/name-resolution.egg deleted file mode 100644 index 2ef292c..0000000 --- a/tests/name-resolution.egg +++ /dev/null @@ -1,25 +0,0 @@ -(datatype Math - (Add Math Math) - (Num i64)) - -(let zero (Num 0)) - - -;; zero here refers to the function/constant zero, not a free variable -(rewrite (Add zero x) x) - -(let a (Add (Num 0) (Num 3))) -(let b (Add (Num 7) (Num 9))) -(let c (Num 16)) -(union b c) - -;; crash if we merge two numbers -(rule ( - (= (Num x) (Num y)) - (!= x y) -)( - (panic "ahhh") -)) - - -(run 10) \ No newline at end of file diff --git a/tests/path-union.egg b/tests/path-union.egg deleted file mode 100644 index 8f2b631..0000000 --- a/tests/path-union.egg +++ /dev/null @@ -1,21 +0,0 @@ -(datatype Node - (mk i64)) - -(relation edge (Node Node)) -(relation path (Node Node)) - -(rule ((edge x y)) - ((path x y))) - -(rule ((path x y) (edge y z)) - ((path x z))) - -(edge (mk 1) (mk 2)) -(edge (mk 2) (mk 3)) -(edge (mk 5) (mk 6)) - -(union (mk 3) (mk 5)) - -(run 10) -(check (edge (mk 3) (mk 6))) -(check (path (mk 1) (mk 6))) \ No newline at end of file diff --git a/tests/path.egg b/tests/path.egg deleted file mode 100644 index 6287c03..0000000 --- a/tests/path.egg +++ /dev/null @@ -1,19 +0,0 @@ -(relation path (i64 i64)) -(relation edge (i64 i64)) - -(rule ((edge x y)) - ((path x y))) - -(rule ((path x y) (edge y z)) - ((path x z))) - -(edge 1 2) -(edge 2 3) -(edge 3 4) -(check (edge 1 2)) -(fail (check (path 1 2))) -(run 3) - -(print-function path 100) -(check (path 1 4)) -(fail (check (path 4 1))) diff --git a/tests/pathproof.egg b/tests/pathproof.egg deleted file mode 100644 index f158ddf..0000000 --- a/tests/pathproof.egg +++ /dev/null @@ -1,30 +0,0 @@ -; proofs of connectivity are paths -(datatype Proof - (Trans i64 Proof) - (Edge i64 i64)) - -; We enhance the path relation to carry a proof field -(relation path (i64 i64 Proof)) -(relation edge (i64 i64)) - -(edge 2 1) -(edge 3 2) -(edge 1 3) - -(rule ((edge x y)) - ((path x y (Edge x y)))) -(rule ((edge x y) (path y z p)) - ((path x z (Trans x p)))) - -; We consider equal all paths tha connect same points. -; Smallest Extraction will extract shortest path. -(rule ((path x y p1) (path x y p2)) - ((union p1 p2))) - -(run 3) -(check (path 3 1 (Trans 3 (Edge 2 1)))) -; Would prefer being able to check -;(check (path 1 2 _)) -; or extract -;(query-extract (path 1 4 ?p)) -(print-function path 100) \ No newline at end of file diff --git a/tests/points-to.egg b/tests/points-to.egg deleted file mode 100644 index a4401f3..0000000 --- a/tests/points-to.egg +++ /dev/null @@ -1,63 +0,0 @@ -; Identifiers represented as strings, keep some newtypes around to aid clarity -(datatype ClassT (Class String)) -(datatype FieldT (Field String)) - -(datatype Stmt - (New String ClassT) - ; Assign dst src - (Assign String String) - ; Store dst field src - (Store String FieldT String) - ; Load dst src field - (Load String String FieldT)) - -(relation VarPointsTo (String ClassT)) -(relation HeapPointsTo (ClassT FieldT ClassT)) - -; New variables point to classes they're initialized as -(rule ((= x (New a b))) ((VarPointsTo a b))) - -; If I assign v1 <- v2 and v2 points to a class c2, then v1 points to class c2 -; as well -(rule ((= x (Assign v1 v2)) (VarPointsTo v2 c2)) - ((VarPointsTo v1 c2))) - -; If c1.f points to c2, and v2 points to class c1, then assigning v1 <- v2.f -; means v1 points to c2 -(rule ((= x (Load v1 v2 f)) - (VarPointsTo v2 c1) - (HeapPointsTo c1 f c2)) - ((VarPointsTo v1 c2))) - -; If v1 points to class c1, and v2 to c2, and if v1.f <- v2, then c1.f points to -; c2 -(rule ((= x (Store v1 f v2)) - (VarPointsTo v1 c1) - (VarPointsTo v2 c2)) - ((HeapPointsTo c1 f c2))) - -; Example in "From Datalog to Flix" -; l1: ClassA o1 = new ClassA(); -; l2: ClassB o2 = new ClassB(); -; l3: ClassB o3 = o2; -; l4: o2.f = o1; -; l5: Object r = o3.f; - -(let A (Class "A")) -(let B (Class "B")) -(let f (Field "f")) - -(let l1 (New "o1" A)) -(let l2 (New "o2" B)) -(let l3 (Assign "o3" "o2")) -(let l4 (Store "o2" f "o1")) -(let l5 (Load "r" "o3" f)) - -(run 3) - -(check (VarPointsTo "o1" A)) -(check (VarPointsTo "o2" B)) - -(check (VarPointsTo "o3" B)) -(check (HeapPointsTo B f A)) -(check (VarPointsTo "r" A)) \ No newline at end of file diff --git a/tests/primitives.egg b/tests/primitives.egg deleted file mode 100644 index a0239e9..0000000 --- a/tests/primitives.egg +++ /dev/null @@ -1,5 +0,0 @@ -(check (= (+ 2 2) 4)) -(check (= (- 2 1) 1)) -(check (= (- 1 2) -1)) -(check (< 1 2)) -(check (> 1 -2)) \ No newline at end of file diff --git a/tests/prims.egg b/tests/prims.egg deleted file mode 100644 index fcfcb2e..0000000 --- a/tests/prims.egg +++ /dev/null @@ -1,124 +0,0 @@ -; A nasty, imperative implementation of Prim's algorithm... in egglog! -; https://en.wikipedia.org/wiki/Prim%27s_algorithm - -; Weighted edge (vertex 1 * vertex 2 * weight) -(datatype edge (Edge i64 i64 i64)) -(relation edge-exists (edge)) - -(relation mytrue ()) -(mytrue) -(let infinity 99999999) ; close enough - -; ==== PROBLEM INSTANCES ==== - -; Graph 1 -; (1)--2--(2) -; \ | -; 1 2 -; \ | -; (3)--3--(4) -(ruleset graph1) -(rule ((mytrue)) - ((edge-exists (Edge 1 2 2)) - (edge-exists (Edge 1 4 1)) - (edge-exists (Edge 2 4 2)) - (edge-exists (Edge 3 4 3))) - :ruleset graph1) - -; Graph 2 -; (1)-2-(2) (3) -; |\ /| / | -; | 3 5 | 4 | -; 5 X 2 / 5 -; | / \ |/ | -; (4)-4-(5)-7-(6) -(ruleset graph2) -(rule ((mytrue)) - ((edge-exists (Edge 1 2 1)) - (edge-exists (Edge 1 4 5)) - (edge-exists (Edge 1 5 3)) - (edge-exists (Edge 2 4 5)) - (edge-exists (Edge 2 5 2)) - (edge-exists (Edge 3 5 4)) - (edge-exists (Edge 3 6 5)) - (edge-exists (Edge 4 5 4)) - (edge-exists (Edge 5 6 7))) - :ruleset graph2) - -; ==== "INIT" RULESET ==== - -(ruleset init) - -; Graph is undirected -(rule ((= e (Edge x y weight))) - ((union e (Edge y x weight))) - :ruleset init) - -; Whether a vertex is included *so far* (this changes). Returns 0 or 1. -(function vertex-included (i64) i64 :merge (max old new)) - -; All vertices default to being not included (note vertex-included's :merge) -(rule ((edge-exists (Edge x y weight))) - ((set (vertex-included x) 0)) - :ruleset init) - -; Keep track of the current iteration -(function current-iteration () i64 :merge (max old new)) - -; Map iteration to best edge found so far -(function iteration-to-best-edge (i64) edge :merge new) -(function iteration-to-best-edge-weight (i64) i64 :merge new) - -(rule ((mytrue)) - ((set (vertex-included 1) 1) ; Initially just include vertex 1 - (set (current-iteration) 0) - (set (iteration-to-best-edge-weight 0) infinity)) - :ruleset init) - -; === "CHOOSE BEST EDGE" RULESET === - -(relation edge-in-mst (edge)) ; whether an edge is in our solution - -(ruleset choose-best-edge) -(rule ((= i (current-iteration)) - (edge-exists (Edge x y weight)) - (= 1 (vertex-included x)) - (= 0 (vertex-included y)) - (< weight (iteration-to-best-edge-weight i))) - ((set (iteration-to-best-edge-weight i) weight) - (set (iteration-to-best-edge i) (Edge x y weight))) - :ruleset choose-best-edge) - -; === "FINISH ITERATION" RULESET === - -(ruleset finish-iteration) -(rule ((= i (current-iteration)) - (= (Edge x y weight) (iteration-to-best-edge i))) - ((edge-in-mst (Edge x y weight)) ; incorporate chosen best edge - (set (vertex-included x) 1) ; mark its vertices as included - (set (vertex-included y) 1) - (set (current-iteration) (+ i 1)) ; advance iteration - (set (iteration-to-best-edge-weight (+ i 1)) infinity)) - :ruleset finish-iteration) - -; === RUN VIA SCHEDULE === - -(run-schedule - (saturate init graph1) ; change to graph2 to see other example - (saturate (saturate choose-best-edge) finish-iteration) -) - -; === PRINT RESULTS === - -; (print-function edge-in-mst) ; this is not very helpful - -; Just copy canonical edges to solution -(relation solution (i64 i64 i64)) - -(ruleset finalize) -(rule ((edge-in-mst (Edge x y weight)) (< x y)) - ((solution x y weight)) - :ruleset finalize) -(run-schedule (saturate finalize)) - -(print-function solution 100) ; this is better diff --git a/tests/push-pop.egg b/tests/push-pop.egg deleted file mode 100644 index 64aa297..0000000 --- a/tests/push-pop.egg +++ /dev/null @@ -1,11 +0,0 @@ -(function foo () i64 :merge (max old new)) - -(set (foo) 1) -(check (= (foo) 1)) - -(push) -(set (foo) 2) -(check (= (foo) 2)) -(pop) - -(check (= (foo) 1)) \ No newline at end of file diff --git a/tests/repro-define.egg b/tests/repro-define.egg deleted file mode 100644 index 1c2d8cd..0000000 --- a/tests/repro-define.egg +++ /dev/null @@ -1,9 +0,0 @@ -(datatype Nat - (S Nat)) -(function ZeroConst () Nat) -(let Zero (ZeroConst)) - -(let two (S (S Zero))) - -(union two (S (S (S Zero)))) -(check (= two (S (S (S Zero))))) diff --git a/tests/repro-desugar-143.egg b/tests/repro-desugar-143.egg deleted file mode 100644 index 7a07854..0000000 --- a/tests/repro-desugar-143.egg +++ /dev/null @@ -1,40 +0,0 @@ -;; To test on issue #143 -(rule ((= x 1) (= y x)) ()) -(rule ((= x 1) (= y x) (= z y)) ()) - -(function f (i64) i64) - -(set (f 0) 0) - -;; a funky id rule -(rule ((f x) (= x y) (= z y)) ((let a (f z)) (set (f (+ z 1)) (+ a 1)))) - -(run 20) - -(print-function f 100) -(check (= (f 10) 10)) - -(datatype Value (Num i64)) -(function fib (Value) Value) - -;; a funky fibonacci that test on more complex case and user defined datatype -(rule ((= (Num a) (fib (Num x))) - (= (Num b) (fib (Num y))) - (= x1 x) - (= y1 y) - (= a1 a) - (= b1 b) - (= x1 x2) - (= y1 y2) - (= a1 a2) - (= b1 b2) - (= 1 (- x2 y2))) - ((let n (+ x 1)) (let sum (+ a1 b2)) (union (fib (Num n)) (Num sum)))) - -(union (fib (Num 1)) (Num 1)) -(union (fib (Num 2)) (Num 1)) - -(run 20) - -(print-function fib 100) -(check (= (fib (Num 10)) (Num 55))) diff --git a/tests/repro-empty-query.egg b/tests/repro-empty-query.egg deleted file mode 100644 index 30bc567..0000000 --- a/tests/repro-empty-query.egg +++ /dev/null @@ -1,9 +0,0 @@ -(function foo () i64 :merge (min old new)) - -(rule () ((set (foo) 4))) - -(set (foo) 10) - -(run 3) - -(check (= (foo) 4)) \ No newline at end of file diff --git a/tests/repro-equal-constant.egg b/tests/repro-equal-constant.egg deleted file mode 100644 index 6dd8154..0000000 --- a/tests/repro-equal-constant.egg +++ /dev/null @@ -1,9 +0,0 @@ -(function foo () i64 :merge (min old new)) - -(rule ((= (foo) 5)) ((set (foo) 4))) - -(set (foo) 10) - -(run 3) - -(check (!= (foo) 4)) \ No newline at end of file diff --git a/tests/repro-equal-constant2.egg b/tests/repro-equal-constant2.egg deleted file mode 100644 index dd72dd3..0000000 --- a/tests/repro-equal-constant2.egg +++ /dev/null @@ -1,9 +0,0 @@ -(function foo () i64 :merge (min old new)) - -(rule ((= (foo) 10)) ((set (foo) 4))) - -(set (foo) 10) - -(run 3) - -(check (= (foo) 4)) \ No newline at end of file diff --git a/tests/repro-noteqbug.egg b/tests/repro-noteqbug.egg deleted file mode 100644 index 5052e18..0000000 --- a/tests/repro-noteqbug.egg +++ /dev/null @@ -1,11 +0,0 @@ -(datatype r (R i64)) -(union (R 1) (R 2)) - -(check (= (R 1) (R 2))) -(fail (check (!= (R 1) (R 2)))) - -(run 0) - - -(check (= (R 1) (R 2))) -(fail (check (!= (R 1) (R 2)))) diff --git a/tests/repro-primitive-query.egg b/tests/repro-primitive-query.egg deleted file mode 100644 index ebe4443..0000000 --- a/tests/repro-primitive-query.egg +++ /dev/null @@ -1,12 +0,0 @@ -(datatype Math - (Num i64)) - -(Num 1) -(Num 2) - -(rule ((Num ?a) - (Num ?b) - (= (+ ?a ?b) 5)) - ((panic "should not have matched"))) - -(run 100) \ No newline at end of file diff --git a/tests/repro-querybug.egg b/tests/repro-querybug.egg deleted file mode 100644 index 3c9e0c0..0000000 --- a/tests/repro-querybug.egg +++ /dev/null @@ -1,17 +0,0 @@ -(datatype list - (Cons i64 list)) -(function EmptyConst () list) -(let Empty (EmptyConst)) - -(relation eq (list list)) - -(eq Empty Empty) - -; Oddly, this version works: -; (rule ((= x (Cons x1 rest1)) (= y (Cons x2 rest2)) (= 0 (- x1 x2)) (eq rest1 rest2)) -(rule ((= x (Cons x1 rest1)) (= y (Cons x2 rest2)) (= x1 x2) (eq rest1 rest2)) - ((eq (Cons x1 rest1) (Cons x2 rest2)))) - -(let mylist (Cons 1 Empty)) - -(run 100) diff --git a/tests/repro-querybug2.egg b/tests/repro-querybug2.egg deleted file mode 100644 index 1d1f8de..0000000 --- a/tests/repro-querybug2.egg +++ /dev/null @@ -1,15 +0,0 @@ -(datatype Nat - (Num i64) - (OtherNum i64)) - - - -(rule ((= y 2)) - ((union (OtherNum y) (Num y)))) - -(Num 2) - - -(run 100) - -(check (= (OtherNum 2) (Num 2))) diff --git a/tests/repro-querybug3.egg b/tests/repro-querybug3.egg deleted file mode 100644 index 11f8b53..0000000 --- a/tests/repro-querybug3.egg +++ /dev/null @@ -1,31 +0,0 @@ -(datatype VarT) -(datatype Term) -(function App (Term Term) Term) -(function Lam (VarT Term) Term) -(function Var (VarT) Term) -(function Let (VarT Term Term) Term) -(function Add (Term Term) Term) -(function Num (i64) Term) -(function CaseSplit (Term Term Term) Term) -(function Cons (Term Term) Term) -(function Nil () Term) -(function V (String) VarT) -(sort StringSet (Set VarT)) -(function freer (Term) StringSet :merge (set-intersect old new)) - -;;(rule ((= e (App e1 e2)) -;; (= (freer e1) fv1) -;; (= (freer e2) fv2)) -;; ((set (freer e) (set-union fv1 fv2)))) - -(rule ((= e (App e1 e2)) - (= fvar1 (freer e1)) - (= fvar1 fv1) - (= fvar2 (freer e2)) - (= fvar2 fv2)) - ((set (freer e) (set-union fv1 fv2)))) -(rule ((= e (Var v))) ((set (freer e) (set-insert (set-empty) v)))) -(function sum () Term :cost 1000) -(union (sum) (Lam (V "xs") (CaseSplit (Var (V "xs")) (Num 0) (Lam (V "x") (Lam (V "xs'") (Add (Var (V "x")) (App (sum) (Var (V "xs'"))))))))) -(set (freer (sum)) (set-empty)) -(run 100) diff --git a/tests/repro-querybug4.egg b/tests/repro-querybug4.egg deleted file mode 100644 index d00045f..0000000 --- a/tests/repro-querybug4.egg +++ /dev/null @@ -1,9 +0,0 @@ -(sort Nat) -(function Num (i64) Nat) -(function OtherNum (i64) Nat) -(rule ((= fvar5__ 2) (= fvar6__ fvar5__) (= y fvar5__)) - ((union (OtherNum fvar5__) (Num fvar5__)))) - -(Num 2) -(run 100) -(check (= (OtherNum 2) (Num 2))) \ No newline at end of file diff --git a/tests/repro-should-saturate.egg b/tests/repro-should-saturate.egg deleted file mode 100644 index 74c38a1..0000000 --- a/tests/repro-should-saturate.egg +++ /dev/null @@ -1,10 +0,0 @@ - -(function MyMap () i64 :merge (min old new)) - -(set (MyMap) 1) - -(rule ((MyMap)) - ((set (MyMap) 1) - (set (MyMap) 2))) - -(run-schedule (saturate (run))) diff --git a/tests/repro-silly-panic.egg b/tests/repro-silly-panic.egg deleted file mode 100644 index 789ebe3..0000000 --- a/tests/repro-silly-panic.egg +++ /dev/null @@ -1,12 +0,0 @@ -(datatype KAT - (par KAT KAT) -) -(function AConst () KAT) -(let A (AConst)) - -(rewrite (par p p) p) -(rule ((= r (par q r)) (= q (par q r))) ((union r q))) - -; tests -(let q (par A A)) -(run 10) \ No newline at end of file diff --git a/tests/repro-typechecking-schedule.egg b/tests/repro-typechecking-schedule.egg deleted file mode 100644 index cabe90d..0000000 --- a/tests/repro-typechecking-schedule.egg +++ /dev/null @@ -1,6 +0,0 @@ -(rule () ()) - -;; This should type check -(run-schedule - (seq (run :until (= a 1)) - (run :until (= a "s")))) diff --git a/tests/repro-vec-unequal.egg b/tests/repro-vec-unequal.egg deleted file mode 100644 index 1ffaab6..0000000 --- a/tests/repro-vec-unequal.egg +++ /dev/null @@ -1,17 +0,0 @@ -(datatype Math - (Num i64)) - -(sort MathVec (Vec Math)) - -(let v1 (vec-of (Num 1) (Num 2))) -(let v2 (vec-of (Num 2) (Num 2))) - -(fail (check (= v1 v2))) - - -(sort IVec (Vec i64)) - -(let v3 (vec-of 1 2)) -(let v4 (vec-of 2 2)) - -(fail (check (= v3 v4))) \ No newline at end of file diff --git a/tests/resolution.egg b/tests/resolution.egg deleted file mode 100644 index 974958c..0000000 --- a/tests/resolution.egg +++ /dev/null @@ -1,101 +0,0 @@ -; Resolution theorem proving -; -; Traditional resolution theorem provers maintain a clause database -; of formulas in Conjunction Normal Form (CNF a big And of Ors). -; Each clause is a set of positive and negative literals -; The prover saturates this set by taking two clauses -; {a}\/c1 {not a}\/c2 and creating a new clause c1 \/ c2. -; Clauses also are pruned by simplications, unit propagation, -; and subsumption. -; These systems use sophisticated term indexing to find matching clauses - -; A natural question is whether egglog's saturation and term indexing gives -; a leg up towards building one of these systems. A programmable one even, -; with built in support for equality reasoning - -; Resolution is provided by a join -; unit propagation is an equation solving process and egraph substitution -; Clause Simplification is provided by rewrite rules - -; This encoding seems about right but is unsatisfying -; Using AC to encode the set nature of clauses is inefficient - -; An important aspect of these provers that seems challenging to encode shallowly -; is that the match also occurs modulo _unification_. -; The unification variables of each clause are not globally scoped, really -; they are scoped outside the body of each clase in an implicit \forall -; This encoding as it stands really only supports ground atoms modulo equality - -(datatype Bool) -(function TrueConst () Bool) -(let True (TrueConst)) -(function FalseConst () Bool) -(let False (FalseConst)) -(function myor (Bool Bool) Bool) -(function negate (Bool) Bool) - -; clauses are assumed in the normal form (or a (or b (or c False))) - -(union (negate False) True) -(union (negate True) False) - -; "Solving" negation equations -(rule ((= (negate p) True)) ((union p False))) -(rule ((= (negate p) False)) ((union p True))) - -; canonicalize associtivity. "append" for clauses -; terminate with false -(rewrite (myor (myor a b) c) (myor a (myor b c))) -; commutativity -(rewrite (myor a (myor b c)) (myor b (myor a c))) - -;absorption -(rewrite (myor a (myor a b)) (myor a b)) -(rewrite (myor a (myor (negate a) b)) True) - -; simplification -(rewrite (myor False a) a) -(rewrite (myor a False) a) -(rewrite (myor True a) True) -(rewrite (myor a True) True) - -; unit propagation -; This is kind of interesting actually. -; Looks a bit like equation solving - -; The following is not valid egglog but could be? -;(rewrite p True -; :when ((= True (or p False)))) - -(rule ((= True (myor p False))) ((union p True))) - -; resolution -; This counts on commutativity to bubble everything possible up to the front of the clause. -(rule ((= True (myor a as)) (= True (myor (negate a) bs))) - ((union (myor as bs) True))) - -; example predicate -(function p (i64) Bool) -(let p0 (p 0)) -(let p1 (p 1)) -(let p2 (p 2)) -;(union (or p0 (or p1 (or p2 False))) True) -;(union (or (negate p0) (or p1 (or (negate p2) False))) True) -(union (myor p1 (myor (negate p2) False)) True) -(union (myor p2 (myor (negate p0) False)) True) -(union (myor p0 (myor (negate p1) False)) True) -(union p1 False) -(union (myor (negate p0) (myor p1 (myor p2 False))) True) -(run 10) - - -(check (!= True False)) -(check (= p0 False)) -(check (= p2 False)) - -; we could turn the original axioms into _patterns_ in all possible directions. -; Which is kind of compelling -; (rule ((or (pat x))) ) -; or let a unification expansion happen and use thos - - diff --git a/tests/rw-analysis.egg b/tests/rw-analysis.egg deleted file mode 100644 index 154066c..0000000 --- a/tests/rw-analysis.egg +++ /dev/null @@ -1,284 +0,0 @@ -;;;;;;;;;;;;;;;; -;; Abstact Domain -;;;;;;;;;;;;;;;; - -; Top means it can be an arbitrary value -(datatype Val (I i64)) -(function TopConst () Val) -(let Top (TopConst)) -(function TrueConst () Val) -(let True (TrueConst)) -(function FalseConst () Val) -(let False (FalseConst)) -(relation Bool (Val)) -(Bool True) -(Bool False) - -(function merge-val (Val Val) Val) - -(rewrite (merge-val Top x) Top) -(rewrite (merge-val x Top) Top) -(rewrite (merge-val True False) Top) -(rewrite (merge-val True (I x)) Top) -(rewrite (merge-val False True) Top) -(rewrite (merge-val False (I x)) Top) -(rewrite (merge-val (I x) (I y)) Top :when ((!= x y))) -(rewrite (merge-val x x) x) - -(function add-val (Val Val) Val) - -(rewrite (add-val Top x) Top) -(rewrite (add-val x Top) Top) -(rewrite (add-val True x) Top) -(rewrite (add-val False x) Top) -(rewrite (add-val x True) Top) -(rewrite (add-val x False) Top) -(rewrite (add-val (I x) (I y)) (I (+ x y))) - -(function eq-val (Val Val) Val) - -(rewrite (eq-val Top x) Top) -(rewrite (eq-val x Top) Top) -(rewrite (eq-val True False) False) -(rewrite (eq-val True (I x)) False) -(rewrite (eq-val False True) False) -(rewrite (eq-val False (I x)) False) -(rewrite (eq-val (I x) True) False) -(rewrite (eq-val (I x) False) False) -(rewrite (eq-val x x) True) - -(datatype VarT (V String)) -(datatype Loc (L i64)) -(datatype Exp - (Add VarT VarT) - (Eq VarT VarT) - (Var VarT) - (Const Val)) -(datatype ProgStmt - (Ass VarT Exp) - (If VarT Loc Loc) - (Goto Loc) - (Call VarT)) -(function EndConst () ProgStmt) -(let End (EndConst)) -(function Prog (Loc) ProgStmt) -(relation RProg (Loc ProgStmt)) - -(function const-prop (Loc VarT) Val :merge (merge-val old new)) - -;;;;;;;;;;;;;;;; -;; ASS Case -;;;;;;;;;;;;;;;; - -;; PROPAGATION - -; propagate x = k -(rule ( - (RProg (L li) (Ass x (Const k))) -)( - (set (const-prop (L (+ li 1)) x) k) -)) - -; propagate x = a + b (non-constant) -(rule ( - (RProg l (Ass x (Add x1 x2))) - (= v1 (const-prop l x1)) - (= v2 (const-prop l x2)) - (= l (L li)) -)( - (set (const-prop (L (+ li 1)) x) (add-val v1 v2)) -)) - -; propagate x = a == b -(rule ( - (RProg l (Ass x (Eq x1 x2))) - (= v1 (const-prop l x1)) - (= v2 (const-prop l x2)) - (= l (L li)) -)( - (set (const-prop (L (+ li 1)) x) (eq-val v1 v2)) -)) - -; propagate other vars -(rule ( - (RProg (L li) (Ass (V x) e)) - (= val (const-prop (L li) (V y))) - (!= x y) -)( - (set (const-prop (L (+ li 1)) (V y)) val) -)) - -;; TRANSFORMATION - -; generate demand for biop -(rule ( - (= (Prog l) (Ass x (Add x1 x2))) - (= v1 (const-prop l x1)) - (= v2 (const-prop l x2)) -)( - (add-val v1 v2) -)) - -(rule ( - (= (Prog l) (Ass x (Eq x1 x2))) - (= v1 (const-prop l x1)) - (= v2 (const-prop l x2)) -)( - (eq-val v1 v2) -)) - -; replace x = a + b (constant) -(rule ( - (= (Prog l) (Ass x (Add x1 x2))) - (= (I val) (add-val (const-prop l x1) - (const-prop l x2))) -)( - (RProg l (Ass x (Const (I val)))) -)) - -; replace x = a + b (non-contant) -(rule ( - (= (Prog l) (Ass x (Add x1 x2))) - (= Top (add-val (const-prop l x1) - (const-prop l x2))) -)( - (RProg l (Ass x (Add x1 x2))) -)) - -; replace x = a == b (constant) -(rule ( - (= (Prog l) (Ass x (Eq x1 x2))) - (= b (eq-val (const-prop l x1) (const-prop l x2))) - (Bool b) -)( - (RProg l (Ass x (Const b))) -)) - -; replace x = a == b (non-constant) -(rule ( - (= (Prog l) (Ass x (Eq x1 x2))) - (= Top (eq-val (const-prop l x1) (const-prop l x2))) -)( - (RProg l (Ass x (Eq x1 x2))) -)) - -; replace x = k -(rule ( - (= (Prog l) (Ass x (Const val))) -)( - (RProg l (Ass x (Const val))) -)) - -;;;;;;;;;;;;;;;; -;; CALL CASE -;;;;;;;;;;;;;;;; - -;; PROPAGATION -(rule ( - (RProg l (Call f)) - (= val (const-prop l x)) - (= l (L li)) -)( - (set (const-prop (L (+ li 1)) x) val) -)) - -;; TRANSFORMATION -(rule ( - (= (Prog l) (Call f)) -)( - (RProg l (Call f)) -)) - -;;;;;;;;;;;;;;;; -;; IF CASE -;;;;;;;;;;;;;;;; - -;; PROPAGATION -(rule ( - (RProg l (If b l1 l2)) - (= val (const-prop l x)) -)( - (set (const-prop l1 x) val) - (set (const-prop l2 x) val) -)) - -;; TRANSFORMATION - -; replace if true -(rule ( - (= (Prog l) (If b l1 l2)) - (= True (const-prop l b)) -)( - (RProg l (Goto l1)) -)) - -; replace if false -(rule ( - (= (Prog l) (If b l1 l2)) - (= False (const-prop l b)) -)( - (RProg l (Goto l2)) -)) - -; replace if Top -(rule ( - (= (Prog l) (If b l1 l2)) - (= Top (const-prop l b)) -)( - (RProg l (If b l1 l2)) -)) - -;;;;;;;;;;;;;;;; -;; GOTO CASE -;;;;;;;;;;;;;;;; - -;; PROPAGATION -(rule ( - (RProg l1 (Goto l2)) - (= val (const-prop l1 x)) -)( - (set (const-prop l2 x) val) -)) - -;; TRANSFORMATION -(rule ( - (= (Prog l1) (Goto l2)) -)( - (RProg l1 (Goto l2)) -)) - -;;;;;;;;;;;;;;;; -;; TEST -;;;;;;;;;;;;;;;; - -(union (Prog (L 0)) (Ass (V "b") (Const Top))) -(union (Prog (L 1)) (Ass (V "ten") (Const (I 10)))) -(union (Prog (L 2)) (Ass (V "one") (Const (I 1)))) -(union (Prog (L 3)) (Ass (V "zero") (Const (I 0)))) -; x := 10 -(union (Prog (L 4)) (Ass (V "x") (Const (I 10)))) -; while (...) { -(union (Prog (L 5)) (If (V "b") (L 6) (L 13))) -; if (x == 10) { -(union (Prog (L 6)) (Ass (V "cond") (Eq (V "x") (V "ten")))) -(union (Prog (L 7)) (If (V "cond") (L 8) (L 10))) -; DoSomething(); -(union (Prog (L 8)) (Call (V "DoSomething"))) -; } -(union (Prog (L 9)) (Goto (L 12))) -; else { -; DoSomething(); -(union (Prog (L 10)) (Call (V "DoSomethingElse"))) -; x := x + 1; -(union (Prog (L 11)) (Ass (V "x") (Add (V "x") (V "one")))) -;; (union (Prog (L 11)) (Call (V "DoSomethingElse"))) -; } -(union (Prog (L 12)) (Goto (L 5))) -; y := x -(union (Prog (L 13)) (Ass (V "y") (Add (V "x") (V "zero")))) -(union (Prog (L 14)) End) - -(run 20) - -(check (= (const-prop (L 14) (V "y")) (I 10))) - diff --git a/tests/schedule-demo.egg b/tests/schedule-demo.egg deleted file mode 100644 index be2e8ef..0000000 --- a/tests/schedule-demo.egg +++ /dev/null @@ -1,28 +0,0 @@ -; Step with alternating feet, left before right -(relation left (i64)) -(relation right (i64)) - -(left 0) -(right 0) - -(ruleset step-left) -(rule ((left x) (right x)) - ((left (+ x 1))) - :ruleset step-left) - -(ruleset step-right) -(rule ((left x) (right y) (= x (+ y 1))) - ((right x)) - :ruleset step-right) - -(run-schedule - (repeat 10 - (saturate step-right) - (saturate step-left))) - -; We took 10 steps with the left, but the right couldn't go the first round, -; so we took only 9 steps with the right. -(check (left 10)) -(check (right 9)) -(fail (check (left 11))) -(fail (check (right 10))) diff --git a/tests/semi_naive_set_function.egg b/tests/semi_naive_set_function.egg deleted file mode 100644 index e9af5cb..0000000 --- a/tests/semi_naive_set_function.egg +++ /dev/null @@ -1,104 +0,0 @@ -;; From issue#93. The change happened in right-hand-side of a rule may also impact output in semi-naive cases -(push) -(function f (i64) i64 :merge (max old new)) - -(set (f 0) 0) -(set (f 3) 0) - -(rule ((= f0 (f 0))) ((set (f 1) f0))) -(rule ((= f1 (f 1))) ((set (f 2) f1))) - -;; update f3 some iters later to make sure f(0) is inactive -(rule ((= f2 (f 2))) ((set (f 3) 3))) - -(push) - -;; This rule should fire and set f(0) to be 3, but because f0 is inactive, -;; it does not fire (despite that f3 is active now) -(rule ((= f0 (f 0))) ((set (f 0) (f 3)))) - -(run 100) -(print-function f 100) ;; f0 is expected to have value 3, but has 0 in reality. - -(check (= (f 0) 3)) -(check (= (f 1) 3)) -(check (= (f 2) 3)) -(check (= (f 3) 3)) - -(pop) -(push) - -;; variants of the last rule. -(rule ((= f0 (f 0)) (= x 3) (= y x)) ((set (f 0) (f y)))) - -(run 100) -(check (= (f 0) 3)) -(check (= (f 1) 3)) -(check (= (f 2) 3)) -(check (= (f 3) 3)) - -(pop) -(push) - -;; adding let binding -(rule ((= f0 (f 0))) ((let x 3) (let y x) (set (f 0) (f y)))) - -(run 100) -(check (= (f 0) 3)) -(check (= (f 1) 3)) -(check (= (f 2) 3)) -(check (= (f 3) 3)) - -(pop) -(push) - -(function g (i64) i64 :merge (max old new)) -(set (g 0) 3) - -;; bind to another function -(rule ((= f0 (f 0))) ((let x (g 0)) (let y x) (set (f 0) (f y)))) - -(run 100) -(check (= (f 0) 3)) -(check (= (f 1) 3)) -(check (= (f 2) 3)) -(check (= (f 3) 3)) - -(pop) -(pop) - -;; more complicated case, when the evaluation never finish -;; the semi_naive and naive behavior diverage a bit -(function f (i64) i64 :merge (max old new)) - -(set (f 0) 0) -(set (f 3) 0) - -(rule ((= f0 (f 0))) ((set (f 1) (+ 1 f0)))) -(rule ((= f1 (f 1))) ((set (f 2) (+ 1 f1)))) - -(push) - -(rule ((= f2 (f 2))) ((set (f 3) 1))) -(rule ((= f0 (f 0))) ((set (f 0) (f (f 3))))) - - -(run 100) -(print-function f 100) -(check (!= 0 (f 0))) -(check (!= 0 (f 1))) -(check (!= 0 (f 2))) - -(pop) - - -;; id function that will set all int values, but need strong induction. -(function g (i64) i64 :merge (max old new)) -(set (g 0) 0) -(set (g 1) 1) -(rule ((= x (g x)) (= y (g (- x 1)))) ((set (g (+ x 1)) (+ y 2)))) - -(run 100) -(print-function g 100) - -(check (= 20 (g 20))) \ No newline at end of file diff --git a/tests/set.egg b/tests/set.egg deleted file mode 100644 index fd7ed37..0000000 --- a/tests/set.egg +++ /dev/null @@ -1,40 +0,0 @@ -(sort ISetBase (Set i64)) - -; Test set-of -(check (= (set-of 1 2) (set-insert (set-insert (set-empty) 1) 2))) -(check (= (set-of 1 2) (set-insert (set-insert (set-empty) 2) 1))) - -; Test set-union -(check (= (set-union (set-of 1 2) (set-of 3 4)) (set-of 1 2 3 4))) - -; Test set-length -(check (= 0 (set-length (set-empty)))) -(check (= 1 (set-length (set-of 1 1 1)))) -(check (= 2 (set-length (set-of 1 -1 1 1)))) - -; Test set-get -(check (= 1 (set-get (set-of 1 -1 2 4 1) 0))) -(check (= 2 (set-get (set-of 1 -1 2 4 1) 1))) -(check (= 4 (set-get (set-of 1 -1 2 4 1) 2))) -(check (= -1 (set-get (set-of 1 -1 2 4 1) 3))) - -; Test set-remove -(check (= (set-remove (set-of 1 2 3) 3) (set-of 1 2))) - -; Reify set -(sort ISet) -(function IS (ISetBase) ISet) - -(function ISet-get (ISet i64) i64 :unextractable) -(rule ((IS x) (> (set-length x) 0)) - ((set (ISet-get (IS x) 0) (set-get x 0)))) -(rule ((ISet-get (IS x) j) - (= i (+ j 1)) (< i (set-length x))) - ((set (ISet-get (IS x) i) (set-get x i)))) - -(let myset (IS (set-of 2 4 1 4 -1))) -(run 100) -(check (= 1 (ISet-get myset 0))) -(check (= 2 (ISet-get myset 1))) -(check (= 4 (ISet-get myset 2))) -(check (= -1 (ISet-get myset 3))) diff --git a/tests/stratified.egg b/tests/stratified.egg deleted file mode 100644 index ca48817..0000000 --- a/tests/stratified.egg +++ /dev/null @@ -1,28 +0,0 @@ -(relation path (i64 i64)) -(relation edge (i64 i64)) - -(rule ((edge x y)) - ((path x y))) - -(edge 1 2) -(edge 2 3) -(edge 3 4) -(check (edge 1 2)) -(run 3) -(check (path 1 2)) - -(ruleset path-rules) - -(rule ((path x y) (edge y z)) - ((path x z)) - :ruleset path-rules) - -(edge 3 8) -(run path-rules 1) -(check (path 1 3)) - - - -; Should fail -; (check (path 1 4)) -; (check (path 3 8)) diff --git a/tests/string.egg b/tests/string.egg deleted file mode 100644 index 74a879e..0000000 --- a/tests/string.egg +++ /dev/null @@ -1,8 +0,0 @@ -; Tests for the string sort - -; Concatenation -(check (= (+ "a" "bc" "de") "abcde")) -; Counting the number of substring occurances -(check (= (count-matches "ab ab" "ab") 2)) -; replacing a substring -(check (= (replace "ab ab" "ab" "cd") "cd cd")) diff --git a/tests/string_quotes.csv b/tests/string_quotes.csv deleted file mode 100644 index 8baef1b..0000000 --- a/tests/string_quotes.csv +++ /dev/null @@ -1 +0,0 @@ -abc diff --git a/tests/string_quotes.egg b/tests/string_quotes.egg deleted file mode 100644 index 6fca9d5..0000000 --- a/tests/string_quotes.egg +++ /dev/null @@ -1,3 +0,0 @@ -(function f () String) -(input f "tests/string_quotes.csv") -(check (= (f) "abc")) diff --git a/tests/subsume.egg b/tests/subsume.egg deleted file mode 100644 index 09adcf0..0000000 --- a/tests/subsume.egg +++ /dev/null @@ -1,30 +0,0 @@ -;; Let's pretend that we are optimizing mathematical expressions, but for some reason on our compiler -;; multiplying by three is very expensive. So we want to rewrite those forms to three additions instead, and always -;; extract that form. - -(datatype Math - (Num i64) - (Var String) - (Add Math Math) - (Mul Math Math)) - - -(rewrite (Mul (Num 3) x) (Add x (Add x x)) :subsume) - -(let x (Mul (Num 2) (Mul (Num 3) (Var "x")))) - -(run 10) - -; When X is extracted, we get the optimized form, where the * 3 is expanded out -(check (= x (Mul (Num 2) (Add (Var "x") (Add (Var "x") (Var "x")))))) -(extract x) -; Will be (Mul (Num 2) (Add (Var "x") (Add (Var "x") (Var "x")))) - -; Even though it can't be extracted, we can still check that x equal 2 * (3 * x) -(check (= x (Mul (Num 2) (Mul (Num 3) (Var "x"))))) - -; Also if we make multiplication commutative and run that run, we won't get that result either -; since the original expr has been subsumed when it was replaced with the addition -(rewrite (Mul x y) (Mul y x)) -(run 10) -(extract x) diff --git a/tests/terms.rs b/tests/terms.rs deleted file mode 100644 index dc810a2..0000000 --- a/tests/terms.rs +++ /dev/null @@ -1,33 +0,0 @@ -use egglog::*; - -// This file tests the public API to terms. - -#[test] -fn test_termdag_public() { - let mut td = TermDag::default(); - let x = td.var("x".into()); - let seven = td.lit(7.into()); - let f = td.app("f".into(), vec![x, seven]); - assert_eq!(td.to_string(&f), "(f x 7)"); -} - -#[test] -#[should_panic] -fn test_termdag_malicious_client() { - // here is an example of how TermIds can be misused by passing - // them into the wrong DAG. - - let mut td = TermDag::default(); - let x = td.var("x".into()); - // at this point, td = [0 |-> x] - // snapshot the current td - let td2 = td.clone(); - let y = td.var("y".into()); - // now td = [0 |-> x, 1 |-> y] - let f = td.app("f".into(), vec![x.clone(), y.clone()]); - // f is Term::App("f", [0, 1]) - assert_eq!(td.to_string(&f), "(f x y)"); - // recall that td2 = [0 |-> x] - // notice that f refers to index 1, so this crashes: - td2.to_string(&f); -} diff --git a/tests/test-combined-steps.egg b/tests/test-combined-steps.egg deleted file mode 100644 index 059a34b..0000000 --- a/tests/test-combined-steps.egg +++ /dev/null @@ -1,53 +0,0 @@ -; Step with alternating feet, left before right -(relation left (i64)) -(relation right (i64)) -(relation middle (i64)) - -(left 0) -(right 0) - -(ruleset step-left) -(rule ((left x) (right x)) - ((left (+ x 1))) - :ruleset step-left) - -(ruleset step-right) -(rule ((left x) (right y) (= x (+ y 1))) - ((right x)) - :ruleset step-right) - -(ruleset step-middle) -(rule ((left x)) - ((middle x)) - :ruleset step-middle) - -(unstable-combined-ruleset - my-combination - step-left step-right - step-middle) - -(run-schedule (repeat 1 my-combination)) - -(check (left 1)) -(check (right 0)) -;; middle didn't observe anything except original step -(check (middle 0)) -(fail (check (left 2))) -(fail (check (right 1))) -(fail (check (middle 1))) -(fail (check (middle 2))) - - -(run-schedule - (repeat 9 - (saturate step-right) - my-combination - (saturate step-right))) - -(check (left 10)) -(check (right 10)) -;; middle didn't get a chance to observe (left 10) -(check (middle 9)) -(fail (check (middle 10))) -(fail (check (left 11))) -(fail (check (right 11))) diff --git a/tests/test-combined.egg b/tests/test-combined.egg deleted file mode 100644 index fa9df17..0000000 --- a/tests/test-combined.egg +++ /dev/null @@ -1,33 +0,0 @@ -(relation edge (i64 i64)) -(relation path (i64 i64)) - - -(ruleset myrules1) -(rule ((edge x y)) - ((path x y)) - :ruleset myrules1) -(ruleset myrules2) -(rule ((path x y) (edge y z)) - ((path x z)) - :ruleset myrules2) - -(unstable-combined-ruleset myrules-combined - myrules1 myrules2) - - -(edge 0 1) -(edge 1 2) -(edge 2 3) -(edge 2 4) - -(run-schedule - (repeat 3 myrules-combined)) - - -(check (path 0 1)) -(check (path 0 2)) -(check (path 0 3)) -(check (path 0 4)) -(check (path 1 2)) -(check (path 1 3)) -(check (path 1 4)) diff --git a/tests/towers-of-hanoi.egg b/tests/towers-of-hanoi.egg deleted file mode 100644 index 2b8d001..0000000 --- a/tests/towers-of-hanoi.egg +++ /dev/null @@ -1,39 +0,0 @@ -(datatype Stack - (Empty) - (Cons i64 Stack)) - -(function Config (Stack Stack Stack) i64 :merge (min old new)) - -;; move from first stack -(rule ((= len (Config (Cons x a) b c))) - ((set (Config a (Cons x b) c) (+ len 1)) - (set (Config a b (Cons x c)) (+ len 1)))) - -;; move from second stack -(rule ((= len (Config a (Cons x b) c))) - ((set (Config (Cons x a) b c) (+ len 1)) - (set (Config a b (Cons x c)) (+ len 1)))) - -;; move from third stack -(rule ((= len (Config a b (Cons x c)))) - ((set (Config (Cons x a) b c) (+ len 1)) - (set (Config a (Cons x b) c) (+ len 1)))) - -(let e (Empty)) - - -;; initial state [123 _ _] with path "length" 0 -(set (Config (Cons 1 (Cons 2 (Cons 3 e))) e e) 0) - -;; find all reachable states -(run 1000000) - -;; print first 10 tuples -(print-function Config 10) -(print-size Config) - -;; how to long to move to state [_ _ 123] -(query-extract (Config e e (Cons 1 (Cons 2 (Cons 3 e))))) - -;; actually do the assertion -(check (= 5 (Config e e (Cons 1 (Cons 2 (Cons 3 e)))))) \ No newline at end of file diff --git a/tests/tricky-type-checking.egg b/tests/tricky-type-checking.egg deleted file mode 100644 index c791006..0000000 --- a/tests/tricky-type-checking.egg +++ /dev/null @@ -1,138 +0,0 @@ -;;;;;;;;;;;;;;;;;; -;; From repro-constraineq - -;; repro-constraineq -(push) -(rule ((= x 1) (= y x) (= z y)) ()) -(run 1) -(pop) - -;; repro-constraineq2 -(push) -(rule ((= x 1) (= y x)) ()) -(run 1) -(pop) - -;; repro-constraineq3 -(push) -(relation f (i64)) - -(rule ((= x 1) - (= x 2)) - ((f x))) - -(run 1) -(print-function f 10) -(pop) - -;;;;;;;;;;;;;;;;;; -;; Atoms need to be order-insensitive - -;; Issue #196 -(push) -(relation R (i64)) - -(rule - ((= x y) - (= y 1)) - ((R x))) -(run 1) -(check (R 1)) -(pop) - -(push) -(relation R (i64)) - -(rule - ((= x (+ y 1)) - (= y 1)) - ((R x))) -(run 1) -(check (R 2)) -(pop) - -;; Issue #80 -(push) -(datatype TYPE) -(datatype TERM) -(function type (TERM) TYPE) -(function Ob () TYPE) -(function Hom (TERM TERM) TYPE) - -(function id (TERM) TERM) -(rule ((type (id A))) - ((type A))) -(rewrite (type (id A)) - (Hom A A) - :when ((= (type A) (Ob)))) - -(function compose (TERM TERM) TERM) -(rule ((type (compose f g))) - ((type f) - (type g))) -(rewrite (type (compose f g)) - (Hom A C) - :when ((= (type f) (Hom A B)) - (= (type g) (Hom B C)))) - -(birewrite (compose (compose f g) h) - (compose f (compose g h)) - :when ((= (type A) (Ob)) - (= (type B) (Ob)) - (= (type C) (Ob)) - (= (type D) (Ob)) - (= (type f) (Hom A B)) - (= (type g) (Hom B C)) - (= (type h) (Hom C D)))) -(birewrite (compose f (id B)) f - :when ((= (type A) (Ob)) - (= (type B) (Ob)) - (= (type f) (Hom A B)))) -(birewrite (compose (id A) f) f - :when ((= (type A) (Ob)) - (= (type B) (Ob)) - (= (type f) (Hom A B)))) - -(function AConst () TERM) -(let A (AConst)) -(function BConst () TERM) -(let B (BConst)) -(function fConst () TERM) -(let f (fConst)) -(function gConst () TERM) -(let g (gConst)) -(let fog (compose g f)) -(union (type f) (Hom A B)) -(union (type g) (Hom B A)) -(union (type A) (Ob)) -(union (type B) (Ob)) -(type fog) -(run 10) -(print-function type 10) -(check (= (type f) - (type (compose (id A) - (compose f (id B)))))) -(check (= (type fog) - (Hom B B))) -(pop) - - -;;;;;;;;;;;;;;;;;; -;; Finding the right type in case of container types and primitives - -;; Issue #113 - -(push) -(sort MyMap (Map i64 String)) -(sort MyMap1 (Map i64 i64)) - -(let my_map1 (map-insert (map-empty) 1 "one")) -(pop) - -(push) -(sort MyMap1 (Map i64 i64)) -(sort MyMap (Map i64 String)) - -(let my_map1 (map-insert (map-empty) 1 "one")) -(pop) - diff --git a/tests/type-constraints-tests.egg b/tests/type-constraints-tests.egg deleted file mode 100644 index 63c8053..0000000 --- a/tests/type-constraints-tests.egg +++ /dev/null @@ -1,10 +0,0 @@ -(datatype Operand) -(sort VecOperandBase (Vec Operand)) -(datatype VecOperand (VO VecOperandBase)) -(sort VecVecOperandBase (Vec VecOperand)) - -(rule - ((= v1 (vec-of)) - (= v2 (VO v1)) - (= v3 (vec-of v2))) - ()) diff --git a/tests/typecheck.egg b/tests/typecheck.egg deleted file mode 100644 index 886a9c4..0000000 --- a/tests/typecheck.egg +++ /dev/null @@ -1,102 +0,0 @@ -; type checking for simply typed lambda calculus - -(datatype Type - (TArr Type Type) ; t1 -> t2 -) -(function TUnitConst () Type) -(let TUnit (TUnitConst)) - -(datatype Expr - (Lam String Type Expr) ; lam x : t . e - (App Expr Expr) - (Var String) -) -(function MyUnitConst () Expr) -(let MyUnit (MyUnitConst)) - -(datatype Ctx - (Cons String Type Ctx) -) -(function NilConst () Ctx) -(let Nil (NilConst)) - -; ctx |- expr : type -(function typeof (Ctx Expr) Type) - -; ctx |- () : unit -(rewrite (typeof ctx MyUnit) TUnit) - -; ctx; x: t |- x : t -(rewrite (typeof (Cons x t ctx) (Var x)) t) - -; ctx |- f :- t1 -> t2 -; ctx |- e : t1 -; ----------------- -; ctx |- f e : t2 - -(rule ( - (= (typeof ctx (App f e)) t2) -)( - (typeof ctx f) - (typeof ctx e) -)) - -(rule ( - (= (typeof ctx (App f e)) t1) - (= (typeof ctx f) (TArr (typeof ctx e) t2)) -)( - (union t1 t2) -)) - -; ctx |- x : t -; ------------------ y != x -; ctx; y: t |- x : t - -(rewrite (typeof (Cons y ty ctx) (Var x)) - (typeof ctx (Var x)) - :when ((!= x y))) - -; ctx; x: t1 |- e : t2 -; ------------------------------ -; ctx |- lam x: t1. e : t1 -> t2 - -; rhs of rewrite creates demand -(rewrite (typeof ctx (Lam x t1 e)) - (TArr t1 (typeof (Cons x t1 ctx) e))) - -; TEST -; ---- - -; lam x : unit, f : unit -> unit . f x -(let e - (Lam "x" TUnit - (Lam "f" (TArr TUnit TUnit) - (App (Var "f") (Var "x"))))) - -; lam x : unit . x -(let id (Lam "x" TUnit (Var "x"))) -(let t-id (typeof Nil id)) - -; (e () id) = () -(let app-unit-id (App (App e MyUnit) id)) -(let t-app (typeof Nil app-unit-id)) - -(let free (Lam "x" TUnit (Var "y"))) -(let t-free-ill (typeof Nil free)) -(let t-free-1 (typeof (Cons "y" TUnit Nil) free)) -(let t-free-2 (typeof (Cons "y" (TArr (TArr TUnit TUnit) TUnit) Nil) free)) - -(run 15) - -(query-extract t-id) -(check (= t-id (TArr TUnit TUnit))) - -(query-extract t-app) -(check (= t-app TUnit)) - -(query-extract t-free-1) -(check (= t-free-1 (TArr TUnit TUnit))) -(query-extract t-free-2) -(check (= t-free-2 (TArr TUnit (TArr (TArr TUnit TUnit) TUnit)))) -; this will err -; (query-extract t-free-ill) diff --git a/tests/typeinfer.egg b/tests/typeinfer.egg deleted file mode 100644 index d7d7e42..0000000 --- a/tests/typeinfer.egg +++ /dev/null @@ -1,337 +0,0 @@ -;;;;;;;;;;;;;;;;;;;;;; -;; Exprs and Types -;;;;;;;;;;;;;;;;;;;;;; - -(datatype Ident) -(datatype Expr) -(datatype Type) -(datatype Scheme) -(datatype Ctx) -;; TODO: can't do unit right now -(sort QuantifiedVs (Set Ident)) - -(function Fresh (Ident i64) Ident) -(function V (String) Ident) - -(function Var (Ident) Expr) -(function App (Expr Expr) Expr) -(function Abs (Ident Expr) Expr) -(function Let (Ident Expr Expr) Expr) -(function Num (i64) Expr) -(function True () Expr) -(function False () Expr) -(function MyUnit () Expr) - -(function TVar (Ident) Type :cost 3) -(function TArr (Type Type) Type :cost 1) -(function TInt () Type :cost 1) -(function TBool () Type :cost 1) -(function TUnit () Type :cost 1) - -(function Forall (QuantifiedVs Type) Scheme) -(function Nil () Ctx) -(function Cons (Ident Scheme Ctx) Ctx) - -(relation ftvCtx (Ctx QuantifiedVs)) -(relation ftv (Type QuantifiedVs)) -(relation ftvScheme (Scheme QuantifiedVs)) -(relation has-qs (Ctx Type QuantifiedVs)) -(relation has-qs-demand (Ctx Type)) - -;;;;;;;;;;;;;;;;;;;;;; -;; Expression size -;;;;;;;;;;;;;;;;;;;;;; -(relation expr-size (Expr i64)) -(rule ((= e (Num n)))((expr-size e 1))) -(rule ((= e (Var x)))((expr-size e 1))) -;; asserted facts will be cleared so we define them as rules -(rule ((= e (True))) ((expr-size e 1))) -(rule ((= e (False))) ((expr-size e 1))) -(rule ((= e (MyUnit))) ((expr-size e 1))) -(rule ((= e (App e1 e2)) - (expr-size e1 s1) - (expr-size e2 s2)) - ((expr-size e (+ (+ s1 s2) 1)))) -(rule ((= e (Let x e1 e2)) - (expr-size e1 s1) - (expr-size e2 s2)) - ((expr-size e (+ (+ s1 s2) 1)))) -(rule ((= e (Abs x e1)) - (expr-size e1 s1)) - ((expr-size e (+ s1 1)))) - -;;;;;;;;;;;;;;;;;;;;;; -;; Scheme and Context -;;;;;;;;;;;;;;;;;;;;;; - -(rule ((= e (TBool)))((ftv e (set-empty)))) -(rule ((= e (TUnit)))((ftv e (set-empty)))) -(rule ((= e (TInt)))((ftv e (set-empty)))) -(rule ((= e (TVar x)))((ftv e (set-insert (set-empty) x)))) -(rule ((= e (TArr fr to)) - (ftv fr s1) - (ftv to s2)) - ((ftv e (set-union s1 s2)))) -(rule ((= c (Nil))) ((ftvCtx c (set-empty)))) -(rule ((= e (Forall qs t)) - (ftv t fvs)) - ((ftvScheme e (set-diff fvs qs)))) -(rule ((= c (Cons x s n)) - (ftvCtx n fvs1) - (ftvScheme s fvs2)) - ((ftvCtx c (set-union fvs1 fvs2)))) - - -;; TODO: rewrite lookup to use native sets -(function lookup (Ctx Ident) Scheme :cost 1000) -(rewrite (lookup (Cons x s tl) x) s) -(rule ( - (= t (lookup (Cons y s tl) x)) - (!= x y) -)( - (union t (lookup tl x)) -)) - -;;;;;;;;;;;;;;;;;;;;;; -;; Generalization and Instantiation -;;;;;;;;;;;;;;;;;;;;;; - -(function generalize (Ctx Type) Scheme :cost 1000) -(function instantiate (Scheme i64) Type :cost 1000) - -(rule ((has-qs-demand ctx (TInt))) - ((has-qs ctx (TInt) (set-empty)))) -(rule ((has-qs-demand ctx (TBool))) - ((has-qs ctx (TBool) (set-empty)))) -(rule ((has-qs-demand ctx (TUnit))) - ((has-qs ctx (TUnit) (set-empty)))) - -(rule ((has-qs-demand ctx (TArr fr to))) - ((has-qs-demand ctx fr) - (has-qs-demand ctx to))) -(rule ((has-qs-demand ctx (TArr fr to)) - (has-qs ctx fr qs1) - (has-qs ctx to qs2)) - ((has-qs ctx (TArr fr to) (set-union qs1 qs2)))) - -(rule ((has-qs-demand ctx (TVar x)) - (ftvCtx ctx key-set) - (set-contains key-set x)) - ((has-qs ctx (TVar x) (set-empty)))) -(rule ((has-qs-demand ctx (TVar x)) - (ftvCtx ctx key-set) - (set-not-contains key-set x)) - ((has-qs ctx (TVar x) (set-insert (set-empty) x)))) - -(rule ((= sc (generalize ctx t))) - ((has-qs-demand ctx t))) -(rewrite (generalize ctx t) - (Forall qs t) - :when ((has-qs ctx t qs))) - -(function subst-fresh (QuantifiedVs Type i64) Type :cost 1000) -(rewrite (subst-fresh vs (TInt) c) (TInt)) -(rewrite (subst-fresh vs (TBool) c) (TBool)) -(rewrite (subst-fresh vs (TUnit) c) (TUnit)) -(rewrite (subst-fresh vs (TArr fr to) c) - (TArr (subst-fresh vs fr c) (subst-fresh vs to c))) -(rule ((= otype (subst-fresh vs (TVar s) c)) - (set-contains vs s)) - ((union otype (TVar (Fresh s c))))) -(rule ((= otype (subst-fresh vs (TVar s) c)) - (set-not-contains vs s)) - ((union otype (TVar s)))) - -(rewrite (instantiate (Forall vs t) c) - (subst-fresh vs t c)) - -;;;;;;;;;;;;;;;;;;;;;; -;; Injectivity -;;;;;;;;;;;;;;;;;;;;;; - -(rule ((= (TArr fr1 to1) (TArr fr2 to2))) - ((union fr1 fr2) - (union to1 to2))) - -;;;;;;;;;;;;;;;;;;;;;; -;; Type inference -;;;;;;;;;;;;;;;;;;;;;; - -; ctx |- expr : type -(function typeof (Ctx Expr i64) Type :cost 1000) - -;; Basic types (TInt, TBool, TUnit) -(rewrite (typeof ctx (Num x) c) (TInt)) -(rewrite (typeof ctx (True) c) (TBool)) -(rewrite (typeof ctx (False) c) (TBool)) -(rewrite (typeof ctx (MyUnit) c) (TUnit)) - -; sc = lookup(ctx, x) -; t = instantiate(sc) -; --------------- -; ctx |- x : t -(rewrite (typeof ctx (Var x) c) - (instantiate (lookup ctx x) c)) - -(rewrite - (typeof ctx (Abs x e) c) - (TArr (TVar (Fresh x c)) - (typeof (Cons x (Forall (set-empty) (TVar (Fresh x c))) - ctx) - e cc)) - :when ((= cc (+ c 1)))) - -(rule ((= to (typeof ctx (App e1 e2) c)) - (= c1 (+ c 1)) - (expr-size e1 sz) - (= c2 (+ c (+ sz 1)))) - ((union (typeof ctx e1 c1) - (TArr (typeof ctx e2 c2) to)))) - -(rewrite (typeof ctx (Let x e1 e2) c) - (typeof (Cons x (generalize ctx (typeof ctx e1 c1)) - ctx) - e2 c2) - :when ((= c1 (+ c 1)) - (expr-size e1 sz) - (= c2 (+ c (+ sz 1))))) - -;;;;;;;;;;;;;;;;;;;;;; -;; Occurs check -;;;;;;;;;;;;;;;;;;;;;; -(relation occurs-check (Ident Type)) -(function errors () Ident) -(rule ((= (TVar x) (TArr fr to))) - ((occurs-check x fr) - (occurs-check x to))) -(rule ((occurs-check x (TVar x))) - ;; ((set (errors) x))) - ((panic "occurs check fail"))) -(rule ((occurs-check x (TArr fr to))) - ((occurs-check x fr) - (occurs-check x to))) - -(relation base-types (Type)) -(base-types (TInt)) -(base-types (TBool)) -(base-types (TUnit)) -(rule ((base-types t) - (= t (TArr fr to))) - ((panic "Unifying base types with functions")) ) -(rule ((= (TInt) (TBool))) ((panic "Unifying base types"))) -(rule ((= (TInt) (TUnit))) ((panic "Unifying base types"))) -(rule ((= (TBool) (TUnit))) ((panic "Unifying base types"))) -;;;;;;;;;;;;;;;;;;;;;; -;; TEST -;;;;;;;;;;;;;;;;;;;;;; - -(push) -(let id (Abs (V "x") (Var (V "x")))) -(let t-id (typeof (Nil) id 0)) -(run 100) -(check (= t-id (TArr (TVar (Fresh (V "x") 0)) (TVar (Fresh (V "x") 0))))) -(pop) - -(push) -(let let-poly (Let (V "id") (Abs (V "x") (Var (V "x"))) - (App (App (Var (V "id")) (Var (V "id"))) - (App (Var (V "id")) (True))))) -(let t-let-poly (typeof (Nil) let-poly 0)) -(run 100) -(check (= t-let-poly (TBool))) -(pop) - -(push) -(let id-id (App (Abs (V "x") (Var (V "x"))) - (Abs (V "y") (Var (V "y"))))) -(let t-id-id (typeof (Nil) id-id 0)) -(run 100) -(check (= t-id-id (TArr (TVar (Fresh (V "y") 3)) (TVar (Fresh (V "y") 3))))) -(pop) - - -(push) -(let let-true (Let (V "x") (True) (True))) -(let t-let-true (typeof (Nil) let-true 0)) -(run 100) -(check (= t-let-true (TBool))) -(pop) - -(push) - -(let let-var-true (Let (V "x") (True) (Var (V "x")))) -(let t-let-var-true (typeof (Nil) let-var-true 0)) -(run 100) -(check (= t-let-var-true (TBool))) -(pop) - -(push) - -(let abs-id (Abs (V "x") - (Let (V "y") (Abs (V "z") (Var (V "z"))) (Var (V "y"))))) -(let t-abs-id (typeof (Nil) abs-id 0)) -(run 100) -(let x (Fresh (V "x") 0)) -(let z (Fresh (Fresh (V "z") 2) 4)) -(check (= t-abs-id (TArr (TVar x) (TArr (TVar z) (TVar z))))) -(pop) - -(push) - -(let let-env (Let (V "x") (True) - (Let (V "f") (Abs (V "a") (Var (V "a"))) - (Let (V "x") (MyUnit) - (App (Var (V "f")) (Var (V "x"))) - )))) -(let t-let-env (typeof (Nil) let-env 0)) -(run 100) -(check (= t-let-env (TUnit))) -(pop) - -(push) -(let let-env-2a (Let (V "x") (MyUnit) - (Let (V "f") (Abs (V "y") (Var (V "x"))) - (Let (V "x") (True) - (App (Var (V "f")) (Var (V "x"))))))) -(let t-let-env-2a (typeof (Nil) let-env-2a 0)) -(run 100) -(check (= t-let-env-2a (TUnit))) -(pop) - -(push) - -(let let-env-2b (App (Abs (V "x") - (Let (V "f") (Abs (V "y") (Var (V "x"))) - (Let (V "x") (True) - (App (Var (V "f")) (Var (V "x")))))) - (MyUnit))) -(let t-let-env-2b (typeof (Nil) let-env-2b 0)) -(run 100) -(check (= t-let-env-2b (TUnit))) -(pop) - -(push) - -;; ((lambda (x) ((lambda (f) ((lambda (x) (f x)) #t)) (lambda (y) x))) 5) -(let let-env-hard (App (Abs (V "x") - (App (Abs (V "f") - (App (Abs (V "x") (App (Var (V "f")) (Var (V "x")))) - (True))) - (Abs (V "y") (Var (V "x"))))) - (MyUnit))) -(let t-let-env-hard (typeof (Nil) let-env-hard 0)) -(run 100) -(check (= t-let-env-hard (TUnit))) -(pop) - -(push) - -(let let-inst (Let (V "id") (Abs (V "x") (Var (V "x"))) - (Let (V "iid") (Abs (V "y") (Var (V "id"))) - (App (Var (V "iid")) - (App (Var (V "id")) (True))))) ) -(let t-let-inst (typeof (Nil) let-inst 0)) -(run 100) -(check (= t-let-inst (TArr (TVar (Fresh (Fresh (Fresh (V "x") 1) 5) 7)) (TVar (Fresh (Fresh (Fresh (V "x") 1) 5) 7))))) -(pop) - diff --git a/tests/unification-points-to.egg b/tests/unification-points-to.egg deleted file mode 100644 index 9526735..0000000 --- a/tests/unification-points-to.egg +++ /dev/null @@ -1,243 +0,0 @@ -(datatype FuncT (Func String)) -(datatype StmtT (Stmt String)) -(datatype ExprT (Expr String)) -(datatype FieldT (Field String)) -(datatype TypeT (Type String)) -(datatype AllocT (Alloc AllocT) (AllocVar ExprT)) - -(relation func (FuncT ExprT TypeT TypeT)) -(relation func-stmt (FuncT StmtT)) -(relation assign (StmtT TypeT ExprT ExprT)) -(relation field-assign (StmtT ExprT FieldT ExprT)) -(relation store (StmtT ExprT ExprT)) -(relation expr (StmtT ExprT)) -(relation return (StmtT ExprT)) -(relation eq (ExprT ExprT ExprT)) -(relation call (ExprT FuncT ExprT)) -(relation add (ExprT ExprT ExprT)) -(relation field (ExprT ExprT FieldT)) -(relation struct-lit-field (ExprT FieldT ExprT)) -(relation addr (ExprT ExprT FieldT)) -(relation load (ExprT ExprT)) -(relation malloc (ExprT TypeT)) - -;; typedef struct s { -;; int x; -;; int y; -;; } s; - -;; int mul(struct s q) { ... } - -;; int fact(int i) { -;; int c = i == 0; -;; if (c) { -;; return 1; -;; } else { -;; int j = i + -1; -;; int r = fact(j); -;; int prod = mul((struct s){i, r}); -;; return prod; -;; } -;; } -;; (func (Func "fact") (Expr "i") (Type "int") (Type "int")) -;; (func-stmt (Func "fact") (Stmt "int c = i == 0;")) -;; (func-stmt (Func "fact") (Stmt "if ...")) -;; (func-stmt (Func "fact") (Stmt "return 1")) -;; (func-stmt (Func "fact") (Stmt "int j = i + -1")) -;; (func-stmt (Func "fact") (Stmt "int r = fact(j)")) -;; (func-stmt (Func "fact") (Stmt "int prod = mul({ x: i, y: r })")) -;; (func-stmt (Func "fact") (Stmt "return prod")) -;; (assign (Stmt "int c = i == 0") (Type "int") (Expr "c") (Expr "i == 0")) -;; (assign (Stmt "int j = i + -1") (Type "int") (Expr "j") (Expr "i + -1")) -;; (assign (Stmt "int r = fact(j)") (Type "int") (Expr "r") (Expr "fact(j)")) -;; (assign (Stmt "int prod = mul({ x: i, y: r })") (Type "int") (Expr "prod") (Expr "mul({ x: i, y: r })")) -;; (eq (Expr "i == 0") (Expr "i") (Expr "0")) -;; (add (Expr "i + -1") (Expr "i") (Expr "-1")) -;; (call (Expr "fact(j)") (Func "fact") (Expr "j")) -;; (call (Expr "mul({ x: i, y: r })") (Func "mul") (Expr "{ x: i, y: r }")) -;; (return (Stmt "return prod") (Expr "prod")) - -;; typedef struct s { -;; int *x; -;; int *y; -;; } s; - -;; void swap(struct s *r) { -;; int **xp = &(r->x); -;; int **yp = &(r->y); -;; int *a = *xp; -;; int *b = *yp; -;; *xp = a; -;; *yp = b; -;; } - -;; int f(int i) { -;; struct s *sp = malloc(sizeof(struct s)); -;; int *u = malloc(sizeof(int)); -;; int *v = malloc(sizeof(int)); -;; *u = i; -;; *v = i; -;; *sp = (struct s){u, v}; -;; swap(sp); -;; int **zpp = &(sp->x); -;; int *zp = *zpp; -;; return *zp; -;; } -(func (Func "swap") (Expr "r") (Type "void") (Type "{int *x; int *y;}*")) -;; statements -(func-stmt (Func "swap") (Stmt "int **xp = &(r->x)")) -(func-stmt (Func "swap") (Stmt "int **yp = &(r->y)")) -(func-stmt (Func "swap") (Stmt "int *z = *xp")) -(func-stmt (Func "swap") (Stmt "int *w = *yp")) -(func-stmt (Func "swap") (Stmt "*xp = a")) -(func-stmt (Func "swap") (Stmt "*yp = b")) -(assign (Stmt "int **xp = &(r->x)") (Type "int **") (Expr "xp") (Expr "&(r->x)")) -(assign (Stmt "int **yp = &(r->x)") (Type "int **") (Expr "yp") (Expr "&(r->y)")) -(assign (Stmt "int *a = *xp") (Type "int *") (Expr "a") (Expr "*xp")) -(assign (Stmt "int *b = *yp") (Type "int *") (Expr "b") (Expr "*yp")) -(store (Stmt "*xp = a") (Expr "xp") (Expr "a")) -(store (Stmt "*yp = b") (Expr "yp") (Expr "b")) -;; expressions -(addr (Expr "&(r->x)") (Expr "r") (Field "x")) -(addr (Expr "&(r->y)") (Expr "r") (Field "y")) -(load (Expr "*xp") (Expr "xp")) -(load (Expr "*yp") (Expr "yp")) - -(func (Func "f") (Expr "i") (Type "int") (Type "int")) -;; statements -(func-stmt (Func "f") (Stmt "struct s *sp = malloc(sizeof(struct s))")) -(func-stmt (Func "f") (Stmt "int *u = malloc(sizeof(int))")) -(func-stmt (Func "f") (Stmt "int *v = malloc(sizeof(int))")) -(func-stmt (Func "f") (Stmt "*u = i")) -(func-stmt (Func "f") (Stmt "*v = i")) -(func-stmt (Func "f") (Stmt "*sp = (struct s){u, v}")) -(func-stmt (Func "f") (Stmt "swap(sp)")) -(func-stmt (Func "f") (Stmt "int **zpp = &(sp->x)")) -(func-stmt (Func "f") (Stmt "int *zp = *zpp")) -(func-stmt (Func "f") (Stmt "return *zp")) -(assign (Stmt "struct s *sp = malloc(sizeof(struct s))") (Type "struct s*") (Expr "sp") (Expr "malloc(sizeof(struct s))")) -(assign (Stmt "int *u = malloc(sizeof(int))") (Type "int *") (Expr "u") (Expr "malloc(sizeof(int))")) -(assign (Stmt "int *v = malloc(sizeof(int))") (Type "int *") (Expr "v") (Expr "malloc(sizeof(int))")) -(store (Stmt "*u = i") (Expr "u") (Expr "i")) -(store (Stmt "*v = i") (Expr "v") (Expr "i")) -(store (Stmt "*sp = (struct s){u, v}") (Expr "sp") (Expr "(struct s){u, v}")) -(expr (Stmt "swap(sp)") (Expr "swap(sp)")) -(assign (Stmt "int **zpp = &(sp->x)") (Type "int **") (Expr "zpp") (Expr "&(sp->x)")) -(assign (Stmt "int *zp = *zpp") (Type "int *") (Expr "zp") (Expr "*zpp")) -(return (Stmt "return *zp") (Expr "*zp")) -;; expressions -(malloc (Expr "malloc(sizeof(struct s))") (Type "struct s")) -(malloc (Expr "malloc(sizeof(int))") (Type "int")) -(struct-lit-field (Expr "(struct s){u, v}") (Field "x") (Expr "u")) -(struct-lit-field (Expr "(struct s){u, v}") (Field "y") (Expr "v")) -(call (Expr "swap(sp)") (Func "swap") (Expr "sp")) -(addr (Expr "&(sp->x)") (Expr "sp") (Field "x")) -(load (Expr "*zpp") (Expr "zpp")) -(load (Expr "*zp") (Expr "zp")) - -;; a variable points to its allocation -(function expr-points-to (ExprT) AllocT) -(function ptr-points-to (AllocT) AllocT) - -;; If `v = malloc(...)`, then `v -> alloc[v]`. -(rule ( - (assign s t1 v c) - (malloc c t2) -)( - (union (expr-points-to v) (AllocVar v)) -)) - -;; If `t v = e` and `e -> a`, then `v -> a`. -(rule ( - (assign s t v e) - (= (expr-points-to e) a) -)( - (union (expr-points-to v) a) -)) - -;; If `*v = u`, `v -> a`, and `u -> b`, then `a -> b`. -(rule ( - (store s v u) - (= (expr-points-to v) a) - (= (expr-points-to u) b) -)( - (union (ptr-points-to a) b) -)) - -;; If `e.f -> a` then `e -> a`. -(rule ( - (field ef e f) - (= (expr-points-to ef) a) -)( - (union (expr-points-to e) a) -)) - -;; If `e -> a` then `e.f -> a`. -(rule ( - (= (expr-points-to e) a) - (field ef e f) -)( - (union (expr-points-to ef) a) -)) - -;; If `u -> a` and `a -> b`, then `&(u->f) -> b`. -(rule ( - (= (expr-points-to u) a) - (= (ptr-points-to a) b) - (addr e u f) -)( - (union (expr-points-to e) b) -)) - -;; If `u -> a` and `&(u->f) -> b`, then `a -> b`. -(rule ( - (= (expr-points-to u) a) - (addr e u f) - (= (expr-points-to e) b) -)( - (union (ptr-points-to a) b) -)) - -;; If `(struct t){..., x, ...}` and `x -> b`, then `(struct t){..., x, ...} -> b`. -(rule ( - (struct-lit-field l f x) - (= (expr-points-to x) b) -)( - (union (expr-points-to l) b) -)) - -;; If `f(t* x)`, `f(v)`, and `v -> a`, then `x -> a`. -(rule ( - (func f x in out) - (call e f v) - (= (expr-points-to v) a) -)( - (union (expr-points-to x) a) -)) - -;; If `return u` in `f` and `u -> a`, then `f(z) -> a`. -(rule ( - (call e f v) - (func-stmt f s) - (return s u) - (= (expr-points-to u) a) -)( - (union (expr-points-to e) a) -)) - -;; store rule -(rule ( - (load e u) - (= (expr-points-to u) a) - (= (ptr-points-to a) b) -)( - (union (expr-points-to e) b) -)) - -(run 40) - -(check (= (AllocVar (Expr "v")) (AllocVar (Expr "u")))) -(check (!= (AllocVar (Expr "v")) (AllocVar (Expr "sp")))) - -(query-extract :variants 100 (AllocVar (Expr "u"))) -(query-extract :variants 100 (AllocVar (Expr "sp"))) diff --git a/tests/unify.egg b/tests/unify.egg deleted file mode 100644 index 59e3be4..0000000 --- a/tests/unify.egg +++ /dev/null @@ -1,26 +0,0 @@ -(datatype Expr - (Mul Expr Expr) - (Var String) - (Lit i64) -) - -; Assume injectivity of Mul for unification -(rule ((= (Mul a b) (Mul c d))) - ((union a c) - (union b d))) - -;; (relation False (i64)) -; If any Literal make equal to something it can't be, false is derived -;(rule ((= (Lit i) (Lit j)) (!= i j)) -; ((False 0))) -(rule ((= (Lit i) (Mul a b))) - ((panic "Literal cannot be equal to a product"))) - -(union (Mul (Var "a") (Var "a")) - (Mul (Lit 1) (Lit 2))) - - -(run 3) -(check (= (Var "a") (Lit 1))) -(check (= (Lit 2) (Lit 1))) -; (check (False 0)) ;; this should fail because we don't want prove false \ No newline at end of file diff --git a/tests/unstable-fn.egg b/tests/unstable-fn.egg deleted file mode 100644 index a4471d9..0000000 --- a/tests/unstable-fn.egg +++ /dev/null @@ -1,70 +0,0 @@ -(datatype Math - (Num i64) - (Var String) - (Add Math Math) - (Mul Math Math)) - -(rewrite (Mul (Num x) (Num y)) (Num (* x y))) - -(datatype MathList - (Nil) - (Cons Math MathList)) - -(sort MathFn (UnstableFn (Math) Math)) - - -(function square (Math) Math) -(rewrite (square x) (Mul x x)) - -(let square-fn (unstable-fn "square" )) - -;; test that we can call a function -(let squared-3 (unstable-app square-fn (Num 3))) -(check (= squared-3 (square (Num 3)))) - -;; test that we can apply a function to a list - -(function list-map-math (MathList MathFn) MathList) -(rewrite (list-map-math (Nil) fn) (Nil)) -(rewrite (list-map-math (Cons x xs) fn) (Cons (unstable-app fn x) (list-map-math xs fn))) - -(let x (Cons (Num 1) (Cons (Num 2) (Cons (Num 3) (Nil))))) -(let squared-x (list-map-math x square-fn)) -(run-schedule (saturate (run))) -(check (= squared-x (Cons (Num 1) (Cons (Num 4) (Cons (Num 9) (Nil)))))) - -;; Test that we can partially apply a function in a rewrite rule - -(function list-multiply-by (MathList Math) MathList) -(rewrite (list-multiply-by l i) (list-map-math l (unstable-fn "Mul" i))) - -(let doubled-x (list-multiply-by x (Num 2))) -(run-schedule (saturate (run))) -(check (= doubled-x (Cons (Num 2) (Cons (Num 4) (Cons (Num 6) (Nil)))))) - -;; Test we can define a higher order compose function - -(function composed-math (MathFn MathFn Math) Math) -(rewrite (composed-math f g v) (unstable-app f (unstable-app g v))) - -(let square-of-double (unstable-fn "composed-math" square-fn (unstable-fn "Mul" (Num 2)))) - -(let squared-doubled-x (list-map-math x square-of-double)) -(run-schedule (saturate (run))) -(check (= squared-doubled-x (Cons (Num 4) (Cons (Num 16) (Cons (Num 36) (Nil)))))) - - -;; See that it supports primitive values as well -(sort i64Fun (UnstableFn (i64) i64)) - -(function composed-i64-math (MathFn i64Fun i64) Math) -(rewrite (composed-i64-math f g v) (unstable-app f (Num (unstable-app g v)))) - -(let res (composed-i64-math square-fn (unstable-fn "*" 2) 4)) -(run-schedule (saturate (run))) -(check (= res (Num 64))) - -;; Verify that function parsing works with a function with no args -(sort TestNullaryFunction (UnstableFn () Math)) -;; Verify that we know the type of a function based on the string name -(extract (unstable-fn "square")) diff --git a/tests/until.egg b/tests/until.egg deleted file mode 100644 index 24c3a51..0000000 --- a/tests/until.egg +++ /dev/null @@ -1,34 +0,0 @@ -; A simple group -(datatype G) -(function IConst () G) -(let I (IConst)) -(function AConst () G) -(let A (AConst)) -(function BConst () G) -(let B (BConst)) - -(function g* (G G) G) -(function inv (G) G) -(birewrite (g* (g* a b) c) (g* a (g* b c))) ; assoc -(rewrite (g* I a) a) ; idl -(rewrite (g* a I) a) ; idr - -; A is cyclic of period 4 -(rewrite (g* A (g* A (g* A A))) I) - -(let A2 (g* A A)) -(let A4 (g* A2 A2)) -(let A8 (g* A4 A4)) - -; non terminating rule -(relation allgs (G)) -(rule ((allgs x)) ((allgs (g* B x)))) -(allgs A) - -; if you remove :until, this will take a very long time -(run 10000 :until (= A8 I)) -(check (= A8 I)) -(check (!= B A)) -(check (!= I A)) -; If you need multiple stop conditions, consider using a (relation relation stop (unit)) -; With rules filling it in with different stop conditions of interest. diff --git a/tests/vec.egg b/tests/vec.egg deleted file mode 100644 index 1202e41..0000000 --- a/tests/vec.egg +++ /dev/null @@ -1,25 +0,0 @@ -(sort IVec (Vec i64)) - -; Test vec-of -(check (= (vec-of 1 2) (vec-push (vec-push (vec-empty) 1) 2))) - -; Test vec-append -(check (= (vec-append (vec-of 1 2) (vec-of 3 4)) (vec-of 1 2 3 4))) - -; Test vec-pop -(check (= (vec-pop (vec-of 1 2 3)) (vec-of 1 2))) - -; Test vec-not-contains -(check (vec-not-contains (vec-of 1 2 3) 4)) - -; Test vec-contains -(check (vec-contains (vec-of 1 2 3) 2)) - -; Test length -(check (= (vec-length (vec-of 1 2 3)) 3)) - -; Test vec-get -(check (= (vec-get (vec-of 1 2 3) 1) 2)) - -; Test vec-set -(check (= (vec-set (vec-of 1 2 3) 1 4) (vec-of 1 4 3))) From f01e9b217b5427e8577fa462602cbd90e6ca9999 Mon Sep 17 00:00:00 2001 From: Alex Fischman Date: Thu, 5 Dec 2024 16:52:47 -0800 Subject: [PATCH 10/10] Update to commit on main --- Cargo.lock | 2 +- Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 41863b8..7114526 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -354,7 +354,7 @@ checksum = "675e35c02a51bb4d4618cb4885b3839ce6d1787c97b664474d9208d074742e20" [[package]] name = "egglog" version = "0.3.0" -source = "git+https://github.com/Alex-Fischman/egglog.git?branch=remove-r64#555faf4cc5b48d0a3f87a553c7a0d60b1d610915" +source = "git+https://github.com/egraphs-good/egglog.git?rev=7abceef4b2ef94f67b69835bbeabbb2815d5820b#7abceef4b2ef94f67b69835bbeabbb2815d5820b" dependencies = [ "chrono", "clap", diff --git a/Cargo.toml b/Cargo.toml index d24b906..3de69a6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,7 +8,7 @@ harness = false name = "files" [dependencies] -egglog = { git = "https://github.com/Alex-Fischman/egglog.git", branch = "remove-r64" } +egglog = { git = "https://github.com/egraphs-good/egglog.git", rev = "7abceef4b2ef94f67b69835bbeabbb2815d5820b" } num = "0.4.3" lazy_static = "1.4"